@abarcenas/ai-workflow-template 1.44.0 → 1.46.0

package/scripts/bump-version.test.js

@@ -0,0 +1,238 @@
+// ═════════════════════════════════════════════════════════════════════════════
+// bump-version.test.js — Unit tests for the pre-commit version bumper
+// ═════════════════════════════════════════════════════════════════════════════
+//
+// bump-version.js is a top-level script: it reads package.json on import,
+// derives the previous major version from `git show HEAD:package.json`, writes
+// the new version, and stages the file.  Tests therefore mock `fs` and
+// `child_process` so the repository's real package.json is never touched, then
+// re-import the module for each scenario with `vi.resetModules()`.
+//
+// Covered scenarios:
+//   1.  SKIP_BUMP=1                      → logs skip, exits 0, no fs/git calls
+//   2.  SKIP_BUMP=yes                     → same (any non-empty value is truthy)
+//   3.  SKIP_BUMP=0                       → same (string "0" is truthy in Node)
+//   4.  SKIP_BUMP=""                      → falsy, bump proceeds
+//   5.  Minor bump (same major)           → 1.4.7 → 1.5.0
+//   6.  Minor bump with multi-digit minor → 1.10.3 → 1.11.0
+//   7.  No HEAD (git show fails)          → falls back to current major, bumps minor
+//   8.  Major changed                     → 3.2.1 → 3.0.0
+//   9.  Exact serialisation              → 2-space JSON + trailing newline, fields preserved
+//  10.  Git commands                     → `git show HEAD:package.json` then `git add package.json`
+// ═════════════════════════════════════════════════════════════════════════════
+
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest'
+
+vi.mock('fs', () => ({
+  readFileSync: vi.fn(),
+  writeFileSync: vi.fn(),
+}))
+
+vi.mock('child_process', () => ({
+  execSync: vi.fn(),
+}))
+
+import { readFileSync, writeFileSync } from 'fs'
+import { execSync } from 'child_process'
+
+const EXIT_SENTINEL = new Error('__process_exit__')
+
+/**
+ * Re-imports bump-version.js with the current mock state.
+ *
+ * @returns {Promise<void>}
+ */
+async function loadModule() {
+  vi.resetModules()
+  await import('./bump-version.js')
+}
+
+/**
+ * Wires the fs/git mocks for a normal (non-skip) run.
+ *
+ * @param {object}   opts
+ * @param {object}   opts.pkg          - Contents returned for package.json.
+ * @param {object}   [opts.prevPkg]    - Contents returned for HEAD:package.json.
+ * @param {boolean}  [opts.noHead]     - When true, `git show` throws.
+ */
+function mockNormalRun({ pkg, prevPkg, noHead = false }) {
+  readFileSync.mockReturnValue(JSON.stringify(pkg))
+  execSync.mockImplementation((cmd) => {
+    if (cmd === 'git show HEAD:package.json') {
+      if (noHead) throw new Error('fatal: invalid object name HEAD')
+      return JSON.stringify(prevPkg)
+    }
+    return ''
+  })
+}
+
+describe('bump-version.js', () => {
+  let logSpy
+  let exitSpy
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    delete process.env.SKIP_BUMP
+    logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+    exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    delete process.env.SKIP_BUMP
+    logSpy.mockRestore()
+    exitSpy.mockRestore()
+  })
+
+  // ── SKIP_BUMP guard ──────────────────────────────────────────────────────
+
+  it('SKIP_BUMP=1: logs skip message, exits 0, touches nothing', async () => {
+    process.env.SKIP_BUMP = '1'
+    exitSpy.mockImplementation(() => {
+      throw EXIT_SENTINEL
+    })
+
+    await expect(loadModule()).rejects.toBe(EXIT_SENTINEL)
+
+    expect(logSpy).toHaveBeenCalledWith('SKIP_BUMP set — version bump skipped')
+    expect(exitSpy).toHaveBeenCalledWith(0)
+    expect(readFileSync).not.toHaveBeenCalled()
+    expect(writeFileSync).not.toHaveBeenCalled()
+    expect(execSync).not.toHaveBeenCalled()
+  })
+
+  it('SKIP_BUMP=yes: any non-empty value skips the bump', async () => {
+    process.env.SKIP_BUMP = 'yes'
+    exitSpy.mockImplementation(() => {
+      throw EXIT_SENTINEL
+    })
+
+    await expect(loadModule()).rejects.toBe(EXIT_SENTINEL)
+
+    expect(exitSpy).toHaveBeenCalledWith(0)
+    expect(writeFileSync).not.toHaveBeenCalled()
+  })
+
+  it('SKIP_BUMP=0: the string "0" is truthy, so the bump is skipped', async () => {
+    process.env.SKIP_BUMP = '0'
+    exitSpy.mockImplementation(() => {
+      throw EXIT_SENTINEL
+    })
+
+    await expect(loadModule()).rejects.toBe(EXIT_SENTINEL)
+
+    expect(exitSpy).toHaveBeenCalledWith(0)
+    expect(execSync).not.toHaveBeenCalled()
+  })
+
+  it('SKIP_BUMP="": empty string is falsy, so the bump proceeds', async () => {
+    process.env.SKIP_BUMP = ''
+    mockNormalRun({
+      pkg: { name: 'fixture', version: '1.4.7' },
+      prevPkg: { version: '1.4.0' },
+    })
+
+    await loadModule()
+
+    expect(exitSpy).not.toHaveBeenCalled()
+    expect(logSpy).toHaveBeenCalledWith('Version bumped: 1.4.7 → 1.5.0')
+  })
+
+  // ── Version arithmetic ───────────────────────────────────────────────────
+
+  it('same major: bumps the minor and resets the patch', async () => {
+    mockNormalRun({
+      pkg: { name: 'fixture', version: '1.4.7' },
+      prevPkg: { version: '1.4.0' },
+    })
+
+    await loadModule()
+
+    const written = JSON.parse(writeFileSync.mock.calls[0][1])
+    expect(written.version).toBe('1.5.0')
+  })
+
+  it('multi-digit minor: increments numerically (1.10.3 → 1.11.0)', async () => {
+    mockNormalRun({
+      pkg: { name: 'fixture', version: '1.10.3' },
+      prevPkg: { version: '1.9.9' },
+    })
+
+    await loadModule()
+
+    expect(logSpy).toHaveBeenCalledWith('Version bumped: 1.10.3 → 1.11.0')
+  })
+
+  it('no HEAD yet: catch path keeps the current major and bumps the minor', async () => {
+    mockNormalRun({
+      pkg: { name: 'fixture', version: '2.3.1' },
+      noHead: true,
+    })
+
+    await loadModule()
+
+    expect(logSpy).toHaveBeenCalledWith('Version bumped: 2.3.1 → 2.4.0')
+  })
+
+  it('major changed: normalises to N.0.0', async () => {
+    mockNormalRun({
+      pkg: { name: 'fixture', version: '3.2.1' },
+      prevPkg: { version: '2.9.9' },
+    })
+
+    await loadModule()
+
+    expect(logSpy).toHaveBeenCalledWith('Version bumped: 3.2.1 → 3.0.0')
+  })
+
+  // ── Serialisation and git side-effects ───────────────────────────────────
+
+  it('writes 2-space JSON with a trailing newline and preserves other fields', async () => {
+    const pkg = {
+      name: 'fixture',
+      version: '1.4.7',
+      scripts: { test: 'vitest' },
+      keywords: ['a', 'b'],
+    }
+    mockNormalRun({ pkg, prevPkg: { version: '1.0.0' } })
+
+    await loadModule()
+
+    const [path, contents] = writeFileSync.mock.calls[0]
+    expect(path).toMatch(/package\.json$/)
+    expect(contents.endsWith('\n')).toBe(true)
+    expect(contents).toBe(
+      JSON.stringify({ ...pkg, version: '1.5.0' }, null, 2) + '\n',
+    )
+  })
+
+  it('reads HEAD:package.json then stages package.json', async () => {
+    mockNormalRun({
+      pkg: { name: 'fixture', version: '0.9.2' },
+      prevPkg: { version: '0.9.0' },
+    })
+
+    await loadModule()
+
+    expect(execSync).toHaveBeenNthCalledWith(
+      1,
+      'git show HEAD:package.json',
+      { encoding: 'utf8' },
+    )
+    expect(execSync).toHaveBeenNthCalledWith(2, 'git add package.json')
+    expect(execSync).toHaveBeenCalledTimes(2)
+  })
+
+  it('reads package.json from the package root', async () => {
+    mockNormalRun({
+      pkg: { name: 'fixture', version: '1.0.0' },
+      prevPkg: { version: '1.0.0' },
+    })
+
+    await loadModule()
+
+    expect(readFileSync).toHaveBeenCalledWith(
+      expect.stringMatching(/package\.json$/),
+      'utf8',
+    )
+  })
+})

package/scripts/mcp/playwright-mcp-launcher.js

@@ -6,41 +6,67 @@
  * based on environment variables and project settings.
  */
 
-const { spawn } = require('child_process');
-const path = require('path');
+import { spawn } from 'node:child_process'
+import { resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
 
-// Get environment variables
-const headless = process.env.HEADLESS === 'true';
-const slowMo = process.env.SLOW_MO ? parseInt(process.env.SLOW_MO) : 0;
+/**
+ * Builds the `npx @playwright/mcp@latest` argument list from the environment.
+ *
+ * @param {NodeJS.ProcessEnv} [env=process.env] - Environment to read.
+ * @returns {string[]} Arguments passed to `npx`.
+ */
+export function buildArgs(env = process.env) {
+  const args = ['@playwright/mcp@latest']
 
-// Build command arguments
-const args = ['@playwright/mcp@latest'];
+  if (env.HEADLESS === 'true') {
+    args.push('--headless')
+  }
 
-// Add headless flag if needed
-if (headless) {
-  args.push('--headless');
-}
+  if (env.VIEWPORT) {
+    args.push('--viewport', env.VIEWPORT)
+  }
 
-// Add viewport size if specified
-if (process.env.VIEWPORT) {
-  args.push('--viewport', process.env.VIEWPORT);
+  return args
 }
 
-// Launch the MCP server
-const child = spawn('npx', args, {
-  stdio: 'inherit',
-  shell: true
-});
+/**
+ * Spawns the Playwright MCP server and forwards signals / exit codes.
+ *
+ * @param {object}   [options]
+ * @param {object}   [options.env=process.env] - Environment to read.
+ * @param {object}   [options.proc=process]    - Process-like emitter for signals.
+ * @param {Function} [options.exit=process.exit] - Exit function.
+ * @returns {import('node:child_process').ChildProcess} The spawned child.
+ */
+export function launch({
+  env = process.env,
+  proc = process,
+  exit = process.exit,
+} = {}) {
+  const child = spawn('npx', buildArgs(env), {
+    stdio: 'inherit',
+    shell: true,
+  })
+
+  proc.on('SIGINT', () => {
+    child.kill('SIGINT')
+  })
+
+  proc.on('SIGTERM', () => {
+    child.kill('SIGTERM')
+  })
 
-// Handle process signals
-process.on('SIGINT', () => {
-  child.kill('SIGINT');
-});
+  child.on('exit', (code) => {
+    exit(code || 0)
+  })
 
-process.on('SIGTERM', () => {
-  child.kill('SIGTERM');
-});
+  return child
+}
 
-child.on('exit', (code) => {
-  process.exit(code || 0);
-});
+const isDirectRun =
+  process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)
+
+if (isDirectRun) {
+  launch()
+}

package/scripts/mcp/playwright-mcp-launcher.test.js

@@ -0,0 +1,217 @@
+// ═════════════════════════════════════════════════════════════════════════════
+// playwright-mcp-launcher.test.js — Unit tests for the MCP launcher
+// ═════════════════════════════════════════════════════════════════════════════
+//
+// `spawn` is mocked so no MCP server is ever launched.  Signal handling and
+// exit-code propagation are exercised through injected fakes (an EventEmitter
+// double for the process and a fake child), plus a direct-run import that
+// verifies the CLI bootstrap branch.
+//
+// Covered scenarios:
+//   1.  default args (no env flags)
+//   2.  HEADLESS=true adds --headless
+//   3.  HEADLESS=false does not
+//   4.  VIEWPORT adds --viewport <size>
+//   5.  HEADLESS + VIEWPORT together
+//   6.  spawn is called as `npx <args>` with inherited stdio + shell
+//   7.  exit code 0 is forwarded
+//   8.  non-zero exit code is forwarded
+//   9.  missing exit code falls back to 0
+//  10.  SIGINT / SIGTERM are forwarded to the child
+//  11.  launch returns the child
+//  12.  direct run auto-launches; imported elsewhere it does not
+// ═════════════════════════════════════════════════════════════════════════════
+
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { EventEmitter } from 'node:events'
+import { fileURLToPath } from 'node:url'
+
+const cp = vi.hoisted(() => ({ spawn: vi.fn() }))
+
+vi.mock('node:child_process', () => ({
+  spawn: cp.spawn,
+}))
+
+import { spawn } from 'node:child_process'
+import { buildArgs, launch } from './playwright-mcp-launcher.js'
+
+/**
+ * Creates a fake ChildProcess.
+ *
+ * @returns {object} Fake child with kill/on and a helper to emit 'exit'.
+ */
+function makeChild() {
+  const handlers = {}
+  return {
+    kill: vi.fn(),
+    on: vi.fn((event, handler) => {
+      handlers[event] = handler
+    }),
+    emitExit(code) {
+      handlers.exit?.(code)
+    },
+  }
+}
+
+describe('playwright-mcp-launcher', () => {
+  let child
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    child = makeChild()
+    spawn.mockReturnValue(child)
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  // ── buildArgs ────────────────────────────────────────────────────────────
+
+  it('buildArgs: returns only the package when no env flags are set', () => {
+    expect(buildArgs({})).toEqual(['@playwright/mcp@latest'])
+  })
+
+  it('buildArgs: HEADLESS=true adds --headless', () => {
+    expect(buildArgs({ HEADLESS: 'true' })).toEqual([
+      '@playwright/mcp@latest',
+      '--headless',
+    ])
+  })
+
+  it('buildArgs: HEADLESS=false does not add --headless', () => {
+    expect(buildArgs({ HEADLESS: 'false' })).toEqual(['@playwright/mcp@latest'])
+  })
+
+  it('buildArgs: VIEWPORT adds a two-token viewport flag', () => {
+    expect(buildArgs({ VIEWPORT: '1280x720' })).toEqual([
+      '@playwright/mcp@latest',
+      '--viewport',
+      '1280x720',
+    ])
+  })
+
+  it('buildArgs: combines headless and viewport flags', () => {
+    expect(buildArgs({ HEADLESS: 'true', VIEWPORT: '800x600' })).toEqual([
+      '@playwright/mcp@latest',
+      '--headless',
+      '--viewport',
+      '800x600',
+    ])
+  })
+
+  // ── launch ───────────────────────────────────────────────────────────────
+
+  it('launch: spawns npx with inherited stdio and shell', () => {
+    launch({ env: {}, proc: new EventEmitter(), exit: vi.fn() })
+
+    expect(spawn).toHaveBeenCalledWith('npx', ['@playwright/mcp@latest'], {
+      stdio: 'inherit',
+      shell: true,
+    })
+  })
+
+  it('launch: returns the spawned child', () => {
+    const returned = launch({
+      env: {},
+      proc: new EventEmitter(),
+      exit: vi.fn(),
+    })
+
+    expect(returned).toBe(child)
+  })
+
+  it('launch: forwards exit code 0', () => {
+    const exit = vi.fn()
+    launch({ env: {}, proc: new EventEmitter(), exit })
+
+    child.emitExit(0)
+
+    expect(exit).toHaveBeenCalledWith(0)
+  })
+
+  it('launch: forwards a non-zero exit code', () => {
+    const exit = vi.fn()
+    launch({ env: {}, proc: new EventEmitter(), exit })
+
+    child.emitExit(5)
+
+    expect(exit).toHaveBeenCalledWith(5)
+  })
+
+  it('launch: falls back to 0 when no exit code is provided', () => {
+    const exit = vi.fn()
+    launch({ env: {}, proc: new EventEmitter(), exit })
+
+    child.emitExit(undefined)
+
+    expect(exit).toHaveBeenCalledWith(0)
+  })
+
+  it('launch: forwards SIGINT to the child', () => {
+    const proc = new EventEmitter()
+    launch({ env: {}, proc, exit: vi.fn() })
+
+    proc.emit('SIGINT')
+
+    expect(child.kill).toHaveBeenCalledWith('SIGINT')
+  })
+
+  it('launch: forwards SIGTERM to the child', () => {
+    const proc = new EventEmitter()
+    launch({ env: {}, proc, exit: vi.fn() })
+
+    proc.emit('SIGTERM')
+
+    expect(child.kill).toHaveBeenCalledWith('SIGTERM')
+  })
+
+  // ── Direct-run guard ─────────────────────────────────────────────────────
+
+  it('direct run: auto-launches when argv[1] is this module', async () => {
+    const modulePath = fileURLToPath(
+      new URL('./playwright-mcp-launcher.js', import.meta.url),
+    )
+    const originalArgv1 = process.argv[1]
+    const intListeners = process.listeners('SIGINT')
+    const termListeners = process.listeners('SIGTERM')
+    process.argv[1] = modulePath
+
+    try {
+      vi.resetModules()
+      await import('./playwright-mcp-launcher.js')
+
+      expect(spawn).toHaveBeenCalledWith(
+        'npx',
+        expect.arrayContaining(['@playwright/mcp@latest']),
+        { stdio: 'inherit', shell: true },
+      )
+    } finally {
+      process.argv[1] = originalArgv1
+      for (const listener of process.listeners('SIGINT')) {
+        if (!intListeners.includes(listener)) {
+          process.removeListener('SIGINT', listener)
+        }
+      }
+      for (const listener of process.listeners('SIGTERM')) {
+        if (!termListeners.includes(listener)) {
+          process.removeListener('SIGTERM', listener)
+        }
+      }
+    }
+  })
+
+  it('imported with an empty argv[1]: does not launch', async () => {
+    const originalArgv1 = process.argv[1]
+    process.argv[1] = ''
+
+    try {
+      vi.resetModules()
+      await import('./playwright-mcp-launcher.js')
+
+      expect(spawn).not.toHaveBeenCalled()
+    } finally {
+      process.argv[1] = originalArgv1
+    }
+  })
+})