movehat 0.2.2 → 0.2.4

package/src/types/config.ts

@@ -77,7 +77,7 @@ export interface LocalTestOptions {
 
     // Common options (both modes)
     autoFund?: boolean;                 // Auto-fund accounts (default: true)
-    defaultBalance?: number;            // Default balance in octas (default: 100_000_000 = 100 APT)
+    defaultBalance?: number;            // Default balance in octas (default: 100_000_000 = 1 MOVE)
     autoDeploy?: readonly string[];     // Modules to auto-deploy (accepts readonly arrays)
     accountLabels?: readonly string[];  // Labels for pre-generated accounts (default: ['deployer', 'alice', 'bob'])
 }

package/src/ui/__tests__/logger.test.ts

@@ -0,0 +1,89 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { configureLogger, isVerbose, divider, phase } from "../logger.js";
+
+describe("logger — verbosity", () => {
+  let originalEnv: string | undefined;
+
+  beforeEach(() => {
+    originalEnv = process.env.MOVEHAT_VERBOSE;
+    // Start each test from a clean slate so prior runs cannot leak.
+    delete process.env.MOVEHAT_VERBOSE;
+    configureLogger({ verbosity: "normal" });
+  });
+
+  afterEach(() => {
+    if (originalEnv === undefined) {
+      delete process.env.MOVEHAT_VERBOSE;
+    } else {
+      process.env.MOVEHAT_VERBOSE = originalEnv;
+    }
+    configureLogger({ verbosity: "normal" });
+  });
+
+  it("defaults to non-verbose when MOVEHAT_VERBOSE is unset and config is normal", () => {
+    expect(isVerbose()).toBe(false);
+  });
+
+  it("returns true when MOVEHAT_VERBOSE=1 (env-driven path)", () => {
+    process.env.MOVEHAT_VERBOSE = "1";
+    expect(isVerbose()).toBe(true);
+  });
+
+  it("returns true when configureLogger({ verbosity: 'verbose' }) is set in-process", () => {
+    configureLogger({ verbosity: "verbose" });
+    expect(isVerbose()).toBe(true);
+  });
+
+  it("env var wins even when in-process config is normal (allows shell-script callers)", () => {
+    configureLogger({ verbosity: "normal" });
+    process.env.MOVEHAT_VERBOSE = "1";
+    expect(isVerbose()).toBe(true);
+  });
+
+  it("non-'1' MOVEHAT_VERBOSE values do not enable verbose mode", () => {
+    process.env.MOVEHAT_VERBOSE = "true";
+    expect(isVerbose()).toBe(false);
+    process.env.MOVEHAT_VERBOSE = "0";
+    expect(isVerbose()).toBe(false);
+  });
+});
+
+describe("logger.phase / logger.divider", () => {
+  let logSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    logSpy = vi.spyOn(console, "log").mockImplementation(() => undefined);
+    configureLogger({ silent: false });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("phase prints three lines: top rule, indented title, bottom rule", () => {
+    phase("Local Movement node");
+    expect(logSpy).toHaveBeenCalledTimes(3);
+
+    const calls = logSpy.mock.calls.map((c: unknown[]) => String(c[0]));
+    // The title line carries the supplied text after the two-space indent.
+    expect(calls[1]).toContain("Local Movement node");
+    // Top and bottom rules should be identical (same width, same color).
+    expect(calls[0]).toBe(calls[2]);
+  });
+
+  it("divider prints a single muted rule line", () => {
+    divider();
+    expect(logSpy).toHaveBeenCalledTimes(1);
+    const line = String(logSpy.mock.calls[0]?.[0] ?? "");
+    // The rule character is `━` (BOX DRAWINGS HEAVY HORIZONTAL).
+    expect(line).toMatch(/━+/);
+  });
+
+  it("phase and divider are silenced when configureLogger({ silent: true })", () => {
+    configureLogger({ silent: true });
+    phase("hidden phase");
+    divider();
+    expect(logSpy).not.toHaveBeenCalled();
+  });
+});

package/src/ui/formatters.ts

@@ -176,7 +176,7 @@ export const indent = (text: string, spaces: number): string => {
  * console.log(divider(40, '='));
  * // ========================================
  */
-export const divider = (
+const divider = (
   width: number = 60,
   char: string = symbols.line
 ): string => {

package/src/ui/logger.ts

@@ -6,6 +6,14 @@ import { coloredSymbol, symbols } from './symbols.js';
  */
 export type LogLevel = 'info' | 'success' | 'error' | 'warning' | 'debug';
 
+/**
+ * Verbosity level for subprocess output and gray-prefixed chatter.
+ * - `quiet`   — reserved; currently behaves like `normal`
+ * - `normal`  — default; system logs only, subprocess chatter hidden
+ * - `verbose` — surface subprocess stdout with a muted gray `›` prefix
+ */
+export type Verbosity = 'quiet' | 'normal' | 'verbose';
+
 /**
  * Logger configuration options
  */
@@ -16,6 +24,8 @@ export interface LoggerConfig {
   level?: LogLevel;
   /** Include timestamps in log messages */
   timestamp?: boolean;
+  /** Verbosity level for subprocess output */
+  verbosity?: Verbosity;
 }
 
 /**
@@ -25,8 +35,18 @@ let config: LoggerConfig = {
   silent: false,
   level: 'info',
   timestamp: false,
+  verbosity: process.env.MOVEHAT_VERBOSE === '1' ? 'verbose' : 'normal',
 };
 
+/**
+ * Whether subprocess chatter should reach the user's terminal.
+ * Honors both the in-process config (set by the `-v` CLI flag's
+ * preAction hook) and the `MOVEHAT_VERBOSE=1` env var (which lets
+ * callers opt in before the CLI parses args, e.g. in shell scripts).
+ */
+export const isVerbose = (): boolean =>
+  config.verbosity === 'verbose' || process.env.MOVEHAT_VERBOSE === '1';
+
 /**
  * Configure logger globally
  *
@@ -186,6 +206,45 @@ export const section = (title: string): void => {
   console.log(`\n${colors.brandBright(title)}`);
 };
 
+/**
+ * Width of the `━` rule used by `phase` and `divider`. Matched to a
+ * comfortable terminal width that fits in a side-by-side dev layout.
+ */
+const PHASE_RULE_WIDTH = 52;
+
+/**
+ * Single muted horizontal rule. Use to close out a phase or to
+ * visually separate output sections.
+ */
+export const divider = (): void => {
+  if (config.silent) return;
+  console.log(colors.muted('━'.repeat(PHASE_RULE_WIDTH)));
+};
+
+/**
+ * Phase header — renders a muted top rule, a bold brand-colored title
+ * indented two spaces, and a muted bottom rule. Use at top-level phase
+ * boundaries (local node start, deploy flow, test orchestrator
+ * sections) so the user can visually anchor where one phase ends and
+ * the next begins.
+ *
+ * @param title - Phase title (e.g. "Local Movement node")
+ *
+ * @example
+ * logger.phase('Local Movement node');
+ * // Renders:
+ * // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ * //   Local Movement node
+ * // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ */
+export const phase = (title: string): void => {
+  if (config.silent) return;
+  const rule = colors.muted('━'.repeat(PHASE_RULE_WIDTH));
+  console.log(rule);
+  console.log(`  ${colors.brandBright(title)}`);
+  console.log(rule);
+};
+
 /**
  * Key-value pair
  * Use for displaying structured data
@@ -235,6 +294,7 @@ export const item = (text: string, indent: number = 0): void => {
  */
 export const logger = {
   configure: configureLogger,
+  isVerbose,
   info,
   success,
   error,
@@ -243,6 +303,8 @@ export const logger = {
   plain,
   newline,
   section,
+  phase,
+  divider,
   kv,
   item,
 };

package/src/ui/spinner.ts

@@ -103,6 +103,53 @@ export const withSpinner = async <T>(
   }
 };
 
+/**
+ * Execute async task with a spinner that updates its label with
+ * elapsed seconds while the task runs. Use for long-running phases
+ * (local node startup, publish + tx wait) where the user wants
+ * visible progress feedback in lieu of subprocess chatter.
+ *
+ * Pairs with the `§9` console-UX convention: any phase that
+ * empirically takes ≥3s in normal use should wrap its body in
+ * `withTimedSpinner` so the terminal never goes silent while work
+ * happens.
+ *
+ * @param label - Stable label shown next to the spinner (e.g. "Starting node")
+ * @param task - Async function to execute
+ * @param indent - Number of spaces to indent (default: 0)
+ * @returns Promise resolving to task result
+ *
+ * @example
+ * await withTimedSpinner('Starting local node', async () => {
+ *   await this.waitForReady(60_000);
+ * });
+ * // Renders: ⠋ Starting local node — 0.0s ... ⠼ Starting local node — 14.2s
+ * // On success: ✔ Starting local node (14.2s)
+ * // On error:   ✖ <error.message>
+ */
+export const withTimedSpinner = async <T>(
+  label: string,
+  task: () => Promise<T>,
+  indent: number = 0
+): Promise<T> => {
+  const start = Date.now();
+  const spin = spinner({ text: `${label} — 0.0s`, indent });
+  const timer = setInterval(() => {
+    spin.text = `${label} — ${((Date.now() - start) / 1000).toFixed(1)}s`;
+  }, 500);
+  try {
+    const result = await task();
+    spin.succeed(`${label} (${((Date.now() - start) / 1000).toFixed(1)}s)`);
+    return result;
+  } catch (error) {
+    const errMsg = error instanceof Error ? error.message : String(error);
+    spin.fail(errMsg);
+    throw error;
+  } finally {
+    clearInterval(timer);
+  }
+};
+
 /**
  * Spinner chain for sequential operations
  * Manages multiple spinners in sequence