movehat 0.2.4 → 0.2.5

package/src/ui/table.ts

@@ -1,191 +0,0 @@
-import Table from 'cli-table3';
-import { shouldUseColor, colors } from './colors.js';
-
-/**
- * Table preset types for different use cases
- */
-export type TablePreset = 'default' | 'compact' | 'markdown' | 'borderless';
-
-/**
- * Column alignment options
- */
-export type Alignment = 'left' | 'center' | 'right';
-
-/**
- * Table configuration options
- */
-export interface TableConfig {
-  /** Column headers */
-  head?: string[];
-  /** Preset style (default: 'default') */
-  preset?: TablePreset;
-  /** Column widths (optional) */
-  colWidths?: number[];
-  /** Column alignments (optional) */
-  colAligns?: Alignment[];
-  /** Custom style overrides */
-  style?: {
-    head?: string[];
-    border?: string[];
-  };
-}
-
-/**
- * Get preset configuration for table styling
- * Automatically respects color settings (NO_COLOR, TTY)
- *
- * @param preset - Preset name
- * @returns Partial cli-table3 configuration
- */
-const getPresetConfig = (preset: TablePreset): Partial<Table.TableConstructorOptions> => {
-  const hasColor = shouldUseColor();
-
-  const presets: Record<TablePreset, Partial<Table.TableConstructorOptions>> = {
-    /**
-     * Default preset - Full borders with colors
-     * Best for: Complex tables with multiple columns
-     */
-    default: {
-      chars: {
-        'top': '─', 'top-mid': '┬', 'top-left': '┌', 'top-right': '┐',
-        'bottom': '─', 'bottom-mid': '┴', 'bottom-left': '└', 'bottom-right': '┘',
-        'left': '│', 'left-mid': '├', 'mid': '─', 'mid-mid': '┼',
-        'right': '│', 'right-mid': '┤', 'middle': '│',
-      },
-      style: {
-        head: hasColor ? ['cyan'] : [],
-        border: hasColor ? ['gray'] : [],
-      },
-    },
-
-    /**
-     * Compact preset - Minimal borders, max readability
-     * Best for: Fork list and similar data displays
-     */
-    compact: {
-      chars: {
-        'top': '', 'top-mid': '', 'top-left': '', 'top-right': '',
-        'bottom': '', 'bottom-mid': '', 'bottom-left': '', 'bottom-right': '',
-        'left': '', 'left-mid': '', 'mid': '', 'mid-mid': '',
-        'right': '', 'right-mid': '', 'middle': ' │ ',
-      },
-      style: {
-        head: hasColor ? ['cyan', 'bold'] : [],
-        border: [],
-      },
-    },
-
-    /**
-     * Markdown preset - Markdown-compatible table format
-     * Best for: Copy-paste to documentation
-     */
-    markdown: {
-      chars: {
-        'top': '', 'top-mid': '', 'top-left': '', 'top-right': '',
-        'bottom': '', 'bottom-mid': '', 'bottom-left': '', 'bottom-right': '',
-        'left': '|', 'left-mid': '', 'mid': '', 'mid-mid': '',
-        'right': '|', 'right-mid': '', 'middle': '|',
-      },
-      style: {
-        head: hasColor ? ['cyan'] : [],
-        border: [],
-      },
-    },
-
-    /**
-     * Borderless preset - Clean, minimal appearance
-     * Best for: Key-value displays and metadata
-     */
-    borderless: {
-      chars: {
-        'top': '', 'top-mid': '', 'top-left': '', 'top-right': '',
-        'bottom': '', 'bottom-mid': '', 'bottom-left': '', 'bottom-right': '',
-        'left': '', 'left-mid': '', 'mid': '', 'mid-mid': '',
-        'right': '', 'right-mid': '', 'middle': '  ',
-      },
-      style: {
-        head: hasColor ? ['cyan', 'bold'] : [],
-        border: [],
-      },
-    },
-  };
-
-  return presets[preset];
-};
-
-/**
- * Create a table with preset configuration
- * Wrapper around cli-table3 with Movehat-specific styling
- *
- * @param config - Table configuration
- * @returns cli-table3 Table instance
- *
- * @example
- * const table = createTable({
- *   head: ['Name', 'Network', 'Chain ID', 'Accounts'],
- *   preset: 'compact'
- * });
- *
- * table.push(['testnet-fork', 'testnet', '126', '5']);
- * table.push(['mainnet-fork', 'mainnet', '1', '3']);
- *
- * console.log(table.toString());
- */
-export const createTable = (config: TableConfig = {}): Table.Table => {
-  const {
-    head,
-    preset = 'default',
-    colWidths,
-    colAligns,
-    style = {},
-  } = config;
-
-  const presetConfig = getPresetConfig(preset);
-
-  const tableConfig: Table.TableConstructorOptions = {
-    ...presetConfig,
-    style: {
-      ...presetConfig.style,
-      ...style,
-    },
-  };
-
-  // Only add optional properties if they are defined
-  if (head) tableConfig.head = head;
-  if (colWidths) tableConfig.colWidths = colWidths;
-  if (colAligns) tableConfig.colAligns = colAligns;
-
-  return new Table(tableConfig);
-};
-
-/**
- * Create a simple key-value table
- * Perfect for displaying metadata and configuration
- *
- * @param data - Object with key-value pairs
- * @param preset - Table preset to use (default: 'borderless')
- * @returns cli-table3 Table instance ready for display
- *
- * @example
- * const metadata = {
- *   'Chain ID': '126',
- *   'Network': 'testnet',
- *   'Ledger Version': '12345',
- *   'Created At': new Date().toLocaleString()
- * };
- *
- * const table = createKVTable(metadata);
- * console.log(table.toString());
- */
-export const createKVTable = (
-  data: Record<string, string | number>,
-  preset: TablePreset = 'borderless'
-): Table.Table => {
-  const table = createTable({ preset });
-
-  for (const [key, value] of Object.entries(data)) {
-    table.push([colors.dim(key), String(value)]);
-  }
-
-  return table;
-};

package/src/utils/__tests__/address.test.ts

@@ -1,93 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  isHexAddress,
-  normalizeAddress,
-  normalizeAddressShort,
-} from '../address.js';
-
-const PADDED_ONE = '0x' + '0'.repeat(63) + '1';
-const PADDED_DEAD = '0x' + '0'.repeat(60) + 'dead';
-
-describe('normalizeAddress', () => {
-  it('pads a short hex to 64 chars and adds 0x', () => {
-    expect(normalizeAddress('1')).toBe(PADDED_ONE);
-  });
-
-  it('preserves a fully padded address', () => {
-    const full = '0x' + 'a'.repeat(64);
-    expect(normalizeAddress(full)).toBe(full);
-  });
-
-  it('lowercases mixed-case input', () => {
-    expect(normalizeAddress('0xDEAD')).toBe(PADDED_DEAD);
-  });
-
-  it('adds the 0x prefix when missing', () => {
-    expect(normalizeAddress('dead')).toBe(PADDED_DEAD);
-  });
-
-  it('returns 0x followed by 64 zeros for empty input', () => {
-    expect(normalizeAddress('')).toBe('0x' + '0'.repeat(64));
-  });
-
-  it('matches fork/manager.ts legacy semantics for the canonical case', () => {
-    // Mirrors the inline `private normalizeAddress` from fork/manager.ts:243.
-    expect(normalizeAddress('0X1')).toBe(PADDED_ONE);
-  });
-});
-
-describe('normalizeAddressShort', () => {
-  it('adds 0x and lowercases without padding', () => {
-    expect(normalizeAddressShort('DEAD')).toBe('0xdead');
-  });
-
-  it('preserves the 0x prefix when already present', () => {
-    expect(normalizeAddressShort('0xBeef')).toBe('0xbeef');
-  });
-
-  it('does not pad a short address', () => {
-    expect(normalizeAddressShort('1')).toBe('0x1');
-  });
-
-  it('returns just 0x for empty input', () => {
-    expect(normalizeAddressShort('')).toBe('0x');
-  });
-});
-
-describe('isHexAddress', () => {
-  it('accepts short hex with 0x prefix', () => {
-    expect(isHexAddress('0x1')).toBe(true);
-  });
-
-  it('accepts hex without 0x prefix', () => {
-    expect(isHexAddress('dead')).toBe(true);
-  });
-
-  it('accepts uppercase 0X prefix', () => {
-    expect(isHexAddress('0Xabc')).toBe(true);
-  });
-
-  it('accepts a full 64-char address', () => {
-    expect(isHexAddress('0x' + 'f'.repeat(64))).toBe(true);
-  });
-
-  it('rejects empty string', () => {
-    expect(isHexAddress('')).toBe(false);
-  });
-
-  it('rejects lone 0x with no hex', () => {
-    expect(isHexAddress('0x')).toBe(false);
-  });
-
-  it('rejects non-hex characters', () => {
-    expect(isHexAddress('0xghij')).toBe(false);
-  });
-
-  it('rejects input longer than 64 hex chars', () => {
-    expect(isHexAddress('0x' + '0'.repeat(65))).toBe(false);
-  });
-
-  it('accepts mixed case hex', () => {
-    expect(isHexAddress('0xAbCdEf')).toBe(true);
-  });
-});

package/src/utils/__tests__/childProcessAdapter.maxBuffer.test.ts

@@ -1,51 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { defaultChildProcessAdapter } from "../childProcessAdapter.js";
-
-/**
- * F4 — `run()` must reject when child output exceeds `maxBuffer`.
- *
- * Without this cap, the stdout/stderr Buffer arrays in
- * DefaultChildProcessAdapter grow without limit. A buggy or hostile
- * subprocess can OOM the parent process. F4 adds an opt-in byte cap
- * with kill-on-overflow semantics.
- */
-
-const NODE = process.execPath;
-
-describe("F4 — ChildProcessAdapter.run maxBuffer", () => {
-  it("rejects with a maxBuffer error when stdout exceeds the cap", async () => {
-    // 8KiB of output, cap at 1KiB → must abort.
-    const script = `process.stdout.write('x'.repeat(8 * 1024)); setTimeout(() => {}, 30000);`;
-    await expect(
-      defaultChildProcessAdapter.run({
-        command: NODE,
-        args: ["-e", script],
-        maxBuffer: 1024,
-        timeoutMs: 10_000,
-      })
-    ).rejects.toThrow(/maxBuffer|exceeded/i);
-  });
-
-  it("rejects with a maxBuffer error when stderr exceeds the cap", async () => {
-    const script = `process.stderr.write('y'.repeat(8 * 1024)); setTimeout(() => {}, 30000);`;
-    await expect(
-      defaultChildProcessAdapter.run({
-        command: NODE,
-        args: ["-e", script],
-        maxBuffer: 1024,
-        timeoutMs: 10_000,
-      })
-    ).rejects.toThrow(/maxBuffer|exceeded/i);
-  });
-
-  it("does NOT throw when output stays under the cap", async () => {
-    const script = `process.stdout.write('ok'); process.exit(0);`;
-    const result = await defaultChildProcessAdapter.run({
-      command: NODE,
-      args: ["-e", script],
-      maxBuffer: 1024,
-    });
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout).toBe("ok");
-  });
-});

package/src/utils/__tests__/childProcessAdapter.test.ts

@@ -1,266 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { defaultChildProcessAdapter } from '../childProcessAdapter.js';
-
-const NODE = process.execPath;
-
-describe('defaultChildProcessAdapter', () => {
-  it('captures stdout and zero exit code on success', async () => {
-    const result = await defaultChildProcessAdapter.run({
-      command: NODE,
-      args: ['-e', "process.stdout.write('hello-stdout')"],
-    });
-
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout).toBe('hello-stdout');
-    expect(result.stderr).toBe('');
-  });
-
-  it('captures stderr separately from stdout', async () => {
-    const result = await defaultChildProcessAdapter.run({
-      command: NODE,
-      args: ['-e', "process.stderr.write('boom'); process.exit(2)"],
-    });
-
-    expect(result.exitCode).toBe(2);
-    expect(result.stdout).toBe('');
-    expect(result.stderr).toBe('boom');
-  });
-
-  it('pipes stdin to the child process', async () => {
-    const result = await defaultChildProcessAdapter.run({
-      command: NODE,
-      args: [
-        '-e',
-        "let d=''; process.stdin.on('data', c => d += c); process.stdin.on('end', () => process.stdout.write(d.toUpperCase()))",
-      ],
-      stdin: 'piped-input',
-    });
-
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout).toBe('PIPED-INPUT');
-  });
-
-  it('passes env to the child process', async () => {
-    const result = await defaultChildProcessAdapter.run({
-      command: NODE,
-      args: ['-e', 'process.stdout.write(process.env.MH_TEST_VAR ?? "missing")'],
-      env: { ...process.env, MH_TEST_VAR: 'present' },
-    });
-
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout).toBe('present');
-  });
-
-  it('rejects when the command times out', async () => {
-    await expect(
-      defaultChildProcessAdapter.run({
-        command: NODE,
-        args: ['-e', 'setTimeout(() => {}, 5000)'],
-        timeoutMs: 50,
-      })
-    ).rejects.toThrow(/timed out/);
-  });
-
-  it('aborts a running command with exitCode -1 and signal SIGTERM', async () => {
-    const controller = new AbortController();
-    const start = Date.now();
-    const promise = defaultChildProcessAdapter.run({
-      command: NODE,
-      args: ['-e', 'setTimeout(() => {}, 5000)'],
-      signal: controller.signal,
-    });
-
-    setTimeout(() => controller.abort(), 20);
-
-    const result = await promise;
-    const elapsed = Date.now() - start;
-
-    expect(result.exitCode).toBe(-1);
-    expect(result.signal).toBe('SIGTERM');
-    expect(elapsed).toBeLessThan(500);
-  });
-
-  it('rejects synchronously when signal is already aborted', async () => {
-    const controller = new AbortController();
-    controller.abort();
-
-    await expect(
-      defaultChildProcessAdapter.run({
-        command: NODE,
-        args: ['-e', "process.stdout.write('never')"],
-        signal: controller.signal,
-      })
-    ).rejects.toThrow(/aborted/);
-  });
-
-  it('rejects when the command does not exist', async () => {
-    await expect(
-      defaultChildProcessAdapter.run({
-        command: '/nonexistent/path/to/binary-xyz',
-        args: [],
-      })
-    ).rejects.toThrow();
-  });
-});
-
-describe('defaultChildProcessAdapter.spawn', () => {
-  it('returns a handle with pid and streams, and exits cleanly when the child finishes on its own', async () => {
-    const child = defaultChildProcessAdapter.spawn({
-      command: NODE,
-      args: ['-e', "process.stdout.write('hi'); process.exit(0)"],
-    });
-
-    expect(typeof child.pid).toBe('number');
-    expect(child.stdout).not.toBeNull();
-    expect(child.stderr).not.toBeNull();
-    expect(child.stdin).not.toBeNull();
-
-    let captured = '';
-    child.stdout?.on('data', (chunk: Buffer) => {
-      captured += chunk.toString('utf8');
-    });
-
-    const result = await child.exited;
-    expect(result.code).toBe(0);
-    expect(result.signal).toBeNull();
-    expect(captured).toBe('hi');
-  });
-
-  it('kill(SIGTERM) terminates a long-running child and surfaces the signal in exited', async () => {
-    const child = defaultChildProcessAdapter.spawn({
-      command: NODE,
-      args: ['-e', 'setInterval(() => {}, 1000)'],
-    });
-
-    const start = Date.now();
-    const killed = child.kill('SIGTERM');
-    expect(killed).toBe(true);
-
-    const result = await child.exited;
-    const elapsed = Date.now() - start;
-
-    expect(result.signal).toBe('SIGTERM');
-    expect(result.code).toBeNull();
-    expect(elapsed).toBeLessThan(500);
-  });
-
-  it('with stdio: ignore, exposes null streams but still resolves exited', async () => {
-    const child = defaultChildProcessAdapter.spawn({
-      command: NODE,
-      args: ['-e', "process.stdout.write('hidden'); process.exit(0)"],
-      stdio: 'ignore',
-    });
-
-    expect(child.stdout).toBeNull();
-    expect(child.stderr).toBeNull();
-    expect(child.stdin).toBeNull();
-
-    const result = await child.exited;
-    expect(result.code).toBe(0);
-  });
-
-  it('exited can be awaited more than once', async () => {
-    const child = defaultChildProcessAdapter.spawn({
-      command: NODE,
-      args: ['-e', 'process.exit(7)'],
-    });
-
-    const first = await child.exited;
-    const second = await child.exited;
-
-    expect(first.code).toBe(7);
-    expect(second.code).toBe(7);
-  });
-
-  it('exited resolves when the command does not exist (error event)', async () => {
-    // Spawning a nonexistent binary fires `error` (ENOENT), not `exit`.
-    // exited must still settle so the caller doesn't hang.
-    const child = defaultChildProcessAdapter.spawn({
-      command: '/nonexistent/path/to/binary-xyz',
-      args: [],
-    });
-
-    const result = await child.exited;
-
-    // When the OS rejects the spawn, no exit code or signal is meaningful.
-    expect(result.code).toBeNull();
-    expect(result.signal).toBeNull();
-  });
-});
-
-describe('defaultChildProcessAdapter.run with inheritStdio', () => {
-  it('returns empty stdout and stderr when inheritStdio is true', async () => {
-    // The child writes to stdout, but the parent inherits stdio so the bytes
-    // never go through the captured pipe — the adapter cannot see them.
-    const result = await defaultChildProcessAdapter.run({
-      command: NODE,
-      args: ['-e', "process.stdout.write('would-be-captured'); process.exit(0)"],
-      inheritStdio: true,
-    });
-
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout).toBe('');
-    expect(result.stderr).toBe('');
-  });
-
-  it('still propagates exit code under inheritStdio', async () => {
-    const result = await defaultChildProcessAdapter.run({
-      command: NODE,
-      args: ['-e', 'process.exit(42)'],
-      inheritStdio: true,
-    });
-
-    expect(result.exitCode).toBe(42);
-    expect(result.stdout).toBe('');
-    expect(result.stderr).toBe('');
-  });
-
-  it('explicit timeoutMs is still honored under inheritStdio', async () => {
-    // Positive control: the conditional-skip applies only when timeoutMs
-    // is omitted. An explicit value forces the timer back on.
-    await expect(
-      defaultChildProcessAdapter.run({
-        command: NODE,
-        args: ['-e', 'setTimeout(() => {}, 5000)'],
-        inheritStdio: true,
-        timeoutMs: 50,
-      })
-    ).rejects.toThrow(/timed out after 50ms/);
-  });
-
-  it('omits the default timeout when inheritStdio is true (short child completes naturally)', async () => {
-    // We can't wait 5 minutes to prove the default timeout isn't set, but
-    // we can prove that a child running with inheritStdio:true and no
-    // explicit timeoutMs completes via the natural exit path with no
-    // timeout-derived rejection. Combined with the test above, the
-    // conditional-skip behavior is pinned in both directions.
-    const result = await defaultChildProcessAdapter.run({
-      command: NODE,
-      args: ['-e', "setTimeout(() => process.exit(0), 50)"],
-      inheritStdio: true,
-    });
-    expect(result.exitCode).toBe(0);
-  });
-
-  it('does not schedule a setTimeout when inheritStdio is true and timeoutMs is omitted', async () => {
-    // Direct evidence (review follow-up): spy on globalThis.setTimeout and
-    // assert no timer scheduled with the DEFAULT_TIMEOUT_MS (300000ms) value.
-    // Short-running children may legitimately schedule small timers via
-    // their own logic, so we filter the spy calls to the default-timeout
-    // duration specifically — that's the value the regression repaired.
-    const setTimeoutSpy = vi.spyOn(globalThis, 'setTimeout');
-    try {
-      await defaultChildProcessAdapter.run({
-        command: NODE,
-        args: ['-e', 'process.exit(0)'],
-        inheritStdio: true,
-      });
-      const defaultTimeoutCalls = setTimeoutSpy.mock.calls.filter(
-        (args) => args[1] === 5 * 60 * 1000
-      );
-      expect(defaultTimeoutCalls).toHaveLength(0);
-    } finally {
-      setTimeoutSpy.mockRestore();
-    }
-  });
-});