@abarcenas/ai-workflow-template 1.45.0 → 1.46.0

package/scripts/setup/discover.test.js

@@ -16,7 +16,7 @@ vi.mock('./utils.js', async (importOriginal) => {
   const actual = await importOriginal()
   return {
     ...actual,
-    getConsumerRoot: () => mockConsumerRoot,
+    getConsumerRoot: vi.fn(() => mockConsumerRoot),
     getNodeVersion: vi.fn(() => 20),
     isCI: vi.fn(() => false),
   }
@@ -24,7 +24,7 @@ vi.mock('./utils.js', async (importOriginal) => {
 
 import { discover } from './discover.js'
 import { HOOK_MARKER, TEMPLATE_HOOKS } from './constants.js'
-import { getNodeVersion, isCI } from './utils.js'
+import { getConsumerRoot, getNodeVersion, isCI } from './utils.js'
 
 // ── Test helpers ──────────────────────────────────────────────────────────
 
@@ -406,3 +406,125 @@ describe('discover()', () => {
     expect(ctx.verbose).toBe(false)
   })
 })
+
+// ── Defensive / early-return paths ─────────────────────────────────────────
+
+describe('discover() — defensive paths', () => {
+  beforeEach(() => {
+    mockConsumerRoot = ''
+    vi.mocked(getConsumerRoot).mockImplementation(() => mockConsumerRoot)
+    vi.mocked(getNodeVersion).mockReturnValue(20)
+    vi.mocked(isCI).mockReturnValue(false)
+  })
+
+  afterEach(() => {
+    vi.mocked(getConsumerRoot).mockImplementation(() => mockConsumerRoot)
+    cleanupTempDirs()
+  })
+
+  it('returns early with just node/CI info when the consumer root is empty', async () => {
+    mockConsumerRoot = ''
+
+    const ctx = await discover()
+
+    expect(ctx.consumerRoot).toBe('')
+    expect(ctx.hasGit).toBe(false)
+    expect(ctx.hasHuskyDir).toBe(false)
+    expect(ctx.hasPackageJson).toBe(false)
+    expect(ctx.consumerPackageJson).toBeNull()
+    expect(ctx.nodeVersion).toBe(20)
+    expect(ctx.isCI).toBe(false)
+    // Every hook keeps its safe default descriptor
+    for (const name of Object.keys(TEMPLATE_HOOKS)) {
+      expect(ctx.existingHooks[name]).toEqual({
+        exists: false,
+        content: null,
+        isManaged: false,
+      })
+    }
+  })
+
+  it('returns early when resolving the consumer root throws', async () => {
+    vi.mocked(getConsumerRoot).mockImplementation(() => {
+      throw new Error('INIT_CWD exploded')
+    })
+    vi.mocked(isCI).mockReturnValue(true)
+
+    const ctx = await discover()
+
+    expect(ctx.consumerRoot).toBe('')
+    expect(ctx.isCI).toBe(true)
+    expect(ctx.nodeVersion).toBe(20)
+    expect(ctx.hasGit).toBe(false)
+  })
+
+  it('falls back to isCI=false when CI detection throws', async () => {
+    const dir = createProject()
+    mockConsumerRoot = dir
+    vi.mocked(isCI).mockImplementation(() => {
+      throw new Error('env exploded')
+    })
+
+    const ctx = await discover()
+
+    expect(ctx.isCI).toBe(false)
+    expect(ctx.hasGit).toBe(true)
+  })
+
+  it('falls back to nodeVersion=0 when version detection throws', async () => {
+    const dir = createProject()
+    mockConsumerRoot = dir
+    vi.mocked(getNodeVersion).mockImplementation(() => {
+      throw new Error('version exploded')
+    })
+
+    const ctx = await discover()
+
+    expect(ctx.nodeVersion).toBe(0)
+  })
+
+  it('treats an unreadable hook path as default when readFile fails', async () => {
+    const dir = createProject({ huskyDir: true })
+    // A directory named like a hook makes safeReadFile throw EISDIR
+    mkdirSync(join(dir, '.husky', 'pre-commit'), { recursive: true })
+    mockConsumerRoot = dir
+
+    const ctx = await discover()
+
+    expect(ctx.existingHooks['pre-commit']).toEqual({
+      exists: false,
+      content: null,
+      isManaged: false,
+    })
+  })
+
+  it('classifies prepare as complex when the classifier itself throws', async () => {
+    const dir = createProject({
+      packageJson: { name: 'trim-test', scripts: { prepare: 'npm run build' } },
+    })
+    mockConsumerRoot = dir
+
+    const originalTrim = String.prototype.trim
+    let calls = 0
+    // discover() trims the prepare script twice before handing it to
+    // isPrepareSimple(); making the third call throw exercises the catch.
+    const spy = vi
+      .spyOn(String.prototype, 'trim')
+      .mockImplementation(function mockedTrim() {
+        calls += 1
+        if (calls === 3) throw new Error('trim exploded')
+        return originalTrim.call(this)
+      })
+
+    let ctx
+    try {
+      ctx = await discover()
+    } finally {
+      spy.mockRestore()
+    }
+
+    expect(calls).toBeGreaterThanOrEqual(3)
+    expect(ctx.existingPrepare).toBe('npm run build')
+    expect(ctx.prepareIsSimple).toBe(false)
+  })
+})

package/scripts/setup/hooks.test.js

@@ -21,7 +21,7 @@
 //  13. Result structure validation                  → all fields present
 // ═════════════════════════════════════════════════════════════════════════════
 
-import { describe, it, expect, afterEach } from 'vitest'
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
 import {
   mkdtempSync,
   mkdirSync,
@@ -143,6 +143,7 @@ describe('installHooks', () => {
       existingHooks: {
         'pre-commit': { exists: false, isManaged: false },
         'post-merge': { exists: false, isManaged: false },
+        'post-commit': { exists: false, isManaged: false },
       },
     })
     mkdirSync(join(ctx.consumerRoot, '.husky'))
@@ -301,6 +302,7 @@ describe('installHooks', () => {
       existingHooks: {
         'pre-commit': { exists: true, isManaged: true },
         'post-merge': { exists: true, isManaged: true },
+        'post-commit': { exists: true, isManaged: true },
       },
     })
     const huskyDir = join(ctx.consumerRoot, '.husky')
@@ -375,6 +377,7 @@ describe('installHooks', () => {
       existingHooks: {
         'pre-commit': { exists: false, isManaged: false },
         'post-merge': { exists: false, isManaged: false },
+        'post-commit': { exists: false, isManaged: false },
       },
     })
     mkdirSync(join(ctx.consumerRoot, '.husky'))
@@ -480,6 +483,7 @@ describe('installHooks', () => {
       existingHooks: {
         'pre-commit': { exists: true, isManaged: false },
         'post-merge': { exists: true, isManaged: false },
+        'post-commit': { exists: true, isManaged: false },
       },
     })
     const huskyDir = join(ctx.consumerRoot, '.husky')
@@ -509,6 +513,7 @@ describe('installHooks', () => {
       existingHooks: {
         'pre-commit': { exists: true, isManaged: true },
         'post-merge': { exists: true, isManaged: true },
+        'post-commit': { exists: true, isManaged: true },
       },
     })
     const huskyDir = join(ctx.consumerRoot, '.husky')
@@ -532,4 +537,186 @@ describe('installHooks', () => {
       expect(r.message).toContain(r.hook)
     }
   })
+  it('force-overwrites a hook that the context reports but disk lost', async () => {
+    // Defensive path: context says the hook exists, but safeReadFile returns
+    // null, so the backup is written with empty content.
+    const ctx = makeContext({
+      hasHuskyDir: true,
+      force: true,
+      existingHooks: {
+        'pre-commit': { exists: true, isManaged: false },
+        'post-merge': { exists: true, isManaged: false },
+        'post-commit': { exists: true, isManaged: false },
+      },
+    })
+    mkdirSync(join(ctx.consumerRoot, '.husky'))
+
+    const results = await installHooks(ctx)
+
+    for (const r of results) {
+      expect(r.action).toBe('overwritten')
+    }
+    const huskyDir = join(ctx.consumerRoot, '.husky')
+    expect(readFileSync(join(huskyDir, 'pre-commit.bak'), 'utf-8')).toBe('')
+    expect(readFileSync(join(huskyDir, 'pre-commit'), 'utf-8')).toBe(
+      expectedContent('pre-commit'),
+    )
+  })
+
+  it('merges against empty content when the reported hook is gone from disk', async () => {
+    const ctx = makeContext({
+      hasHuskyDir: true,
+      existingHooks: {
+        'pre-commit': { exists: true, isManaged: false },
+        'post-merge': { exists: true, isManaged: false },
+        'post-commit': { exists: true, isManaged: false },
+      },
+    })
+    mkdirSync(join(ctx.consumerRoot, '.husky'))
+
+    const results = await installHooks(ctx)
+
+    for (const r of results) {
+      expect(r.action).toBe('merged')
+    }
+    const merged = readFileSync(
+      join(ctx.consumerRoot, '.husky', 'pre-commit'),
+      'utf-8',
+    )
+    expect(merged.startsWith(`\n${HOOK_MERGE_SEPARATOR}\n`)).toBe(true)
+    expect(merged).toContain(expectedContent('pre-commit'))
+  })
+})
+
+// ── 17. Dry-run action classification (all four message branches) ──────────
+
+describe('installHooks — dry-run classification', () => {
+  let logSpy
+
+  beforeEach(() => {
+    logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    logSpy.mockRestore()
+    cleanupTempDirs()
+  })
+
+  it('dry-run describes creating .husky/ when the directory is missing', async () => {
+    const ctx = makeContext({ hasHuskyDir: false, dryRun: true })
+
+    const results = await installHooks(ctx)
+
+    expect(results).toHaveLength(Object.keys(TEMPLATE_HOOKS).length)
+    for (const r of results) {
+      expect(r.action).toBe('dry-run')
+      expect(r.message).toContain('Would create .husky/')
+      expect(r.message).toContain(r.hook)
+      expect(r.message).toContain(
+        TEMPLATE_HOOKS[r.hook].description,
+      )
+    }
+    expect(existsSync(join(ctx.consumerRoot, '.husky'))).toBe(false)
+  })
+
+  it('dry-run describes writing when .husky/ exists without the hook', async () => {
+    const ctx = makeContext({
+      hasHuskyDir: true,
+      dryRun: true,
+      existingHooks: {
+        'pre-commit': { exists: false, isManaged: false },
+        'post-merge': { exists: false, isManaged: false },
+        'post-commit': { exists: false, isManaged: false },
+      },
+    })
+    mkdirSync(join(ctx.consumerRoot, '.husky'))
+
+    const results = await installHooks(ctx)
+
+    for (const r of results) {
+      expect(r.message).toContain('Would write')
+      expect(r.message).not.toContain('Would append')
+    }
+  })
+
+  it('dry-run describes an idempotent overwrite for managed hooks', async () => {
+    const ctx = makeContext({
+      hasHuskyDir: true,
+      dryRun: true,
+      existingHooks: {
+        'pre-commit': { exists: true, isManaged: true },
+        'post-merge': { exists: true, isManaged: true },
+        'post-commit': { exists: true, isManaged: true },
+      },
+    })
+    const huskyDir = join(ctx.consumerRoot, '.husky')
+    mkdirSync(huskyDir)
+    writeFileSync(join(huskyDir, 'pre-commit'), `${HOOK_MARKER}\nold\n`)
+    writeFileSync(join(huskyDir, 'post-merge'), `${HOOK_MARKER}\nold\n`)
+    const before = readFileSync(join(huskyDir, 'pre-commit'), 'utf-8')
+
+    const results = await installHooks(ctx)
+
+    for (const r of results) {
+      expect(r.action).toBe('dry-run')
+      expect(r.message).toContain('idempotent update')
+      expect(r.message).toContain(r.hook)
+    }
+    expect(readFileSync(join(huskyDir, 'pre-commit'), 'utf-8')).toBe(before)
+  })
+
+  it('dry-run describes appending for unmanaged hooks without force', async () => {
+    const ctx = makeContext({
+      hasHuskyDir: true,
+      dryRun: true,
+      force: false,
+      flags: {},
+      existingHooks: {
+        'pre-commit': { exists: true, isManaged: false },
+        'post-merge': { exists: true, isManaged: false },
+        'post-commit': { exists: true, isManaged: false },
+      },
+    })
+    const huskyDir = join(ctx.consumerRoot, '.husky')
+    mkdirSync(huskyDir)
+    writeFileSync(join(huskyDir, 'pre-commit'), '#!/bin/sh\ncustom\n')
+    writeFileSync(join(huskyDir, 'post-merge'), '#!/bin/sh\ncustom\n')
+
+    const results = await installHooks(ctx)
+
+    for (const r of results) {
+      expect(r.action).toBe('dry-run')
+      expect(r.message).toContain('Would append to existing')
+      expect(r.message).not.toContain('force')
+    }
+    expect(readFileSync(join(huskyDir, 'pre-commit'), 'utf-8')).toBe(
+      '#!/bin/sh\ncustom\n',
+    )
+    expect(existsSync(join(huskyDir, 'pre-commit.bak'))).toBe(false)
+  })
+
+  it('dry-run backs up + overwrites when force comes from flags', async () => {
+    const ctx = makeContext({
+      hasHuskyDir: true,
+      dryRun: true,
+      force: false,
+      flags: { force: true },
+      existingHooks: {
+        'pre-commit': { exists: true, isManaged: false },
+        'post-merge': { exists: true, isManaged: false },
+        'post-commit': { exists: true, isManaged: false },
+      },
+    })
+    const huskyDir = join(ctx.consumerRoot, '.husky')
+    mkdirSync(huskyDir)
+
+    const results = await installHooks(ctx)
+
+    for (const r of results) {
+      expect(r.message).toContain('overwrite with force')
+    }
+    // Nothing is actually written or backed up
+    expect(existsSync(join(huskyDir, 'pre-commit'))).toBe(false)
+    expect(existsSync(join(huskyDir, 'pre-commit.bak'))).toBe(false)
+  })
 })

package/scripts/setup/husky-init.test.js

@@ -0,0 +1,311 @@
+// ═════════════════════════════════════════════════════════════════════════════
+// husky-init.test.js — Unit tests for the husky initialization phase
+// ═════════════════════════════════════════════════════════════════════════════
+//
+// The module resolves husky from the CONSUMER's node_modules and calls its
+// programmatic API.  Tests build throwaway consumer projects in temp dirs with
+// a fake `node_modules/husky` fixture, so the real repository is never touched.
+// `child_process.execSync` and `./ui.js` are mocked; `fs` is real.
+//
+// Covered scenarios:
+//   1.  dryRun wins over every other flag      → action=dry-run, nothing runs
+//   2.  CI environment                         → action=skipped + warning
+//   3.  No .git directory                      → action=skipped + console.warn
+//   4.  husky not installed (resolve fails)    → action=skipped + install hint
+//   5.  husky module throws on import          → action=skipped (same catch)
+//   6.  core.hooksPath unset succeeds          → execSync called, action=initialized
+//   7.  core.hooksPath unset throws            → swallowed, action=initialized
+//   8.  husky() throws                         → action=failed with message
+//   9.  .husky/_/h missing post-condition      → action=failed
+//  10.  idempotent second run                  → action=initialized both times
+//  11.  verbose flag forwards progress messages
+// ═════════════════════════════════════════════════════════════════════════════
+
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest'
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from 'fs'
+import { join } from 'path'
+import { tmpdir } from 'os'
+
+vi.mock('child_process', () => ({
+  execSync: vi.fn(),
+}))
+
+vi.mock('./ui.js', () => ({
+  info: vi.fn(),
+  warn: vi.fn(),
+  verbose: vi.fn(),
+}))
+
+import { execSync } from 'child_process'
+import { info, warn, verbose } from './ui.js'
+import { initHusky } from './husky-init.js'
+
+// ── Fake husky fixtures ───────────────────────────────────────────────────
+
+const HUSKY_IMPLEMENTATIONS = {
+  success: `
+const fs = require('fs')
+const path = require('path')
+module.exports = function husky(root) {
+  const dir = path.join(root, '.husky', '_')
+  fs.mkdirSync(dir, { recursive: true })
+  fs.writeFileSync(path.join(dir, 'h'), '#!/bin/sh\\n')
+}
+`,
+  throws: `
+module.exports = function husky() {
+  throw new Error('husky boom')
+}
+`,
+  noop: `
+module.exports = function husky() {}
+`,
+  importThrows: `
+throw new Error('corrupt husky module')
+`,
+}
+
+const tempDirs = new Set()
+
+/**
+ * Creates a temporary consumer project.
+ *
+ * @param {object}   [options]
+ * @param {string}   [options.husky='success'] - Fake husky behaviour key.
+ * @param {boolean}  [options.withPackageJson=true]
+ * @returns {string} Absolute consumer root.
+ */
+function createConsumer({ husky = 'success', withPackageJson = true } = {}) {
+  const dir = mkdtempSync(join(realpathSync(tmpdir()), 'husky-init-test-'))
+  tempDirs.add(dir)
+
+  if (withPackageJson) {
+    writeFileSync(
+      join(dir, 'package.json'),
+      JSON.stringify({ name: 'fixture', version: '1.0.0' }, null, 2) + '\n',
+    )
+  }
+
+  if (husky) {
+    const huskyDir = join(dir, 'node_modules', 'husky')
+    mkdirSync(huskyDir, { recursive: true })
+    writeFileSync(
+      join(huskyDir, 'package.json'),
+      JSON.stringify({ name: 'husky', version: '9.0.0', main: 'index.js' }),
+    )
+    writeFileSync(join(huskyDir, 'index.js'), HUSKY_IMPLEMENTATIONS[husky])
+  }
+
+  return dir
+}
+
+/**
+ * Builds the context object accepted by initHusky().
+ *
+ * @param {string} consumerRoot
+ * @param {object} [overrides]
+ * @returns {object}
+ */
+function makeContext(consumerRoot, overrides = {}) {
+  return {
+    consumerRoot,
+    hasGit: true,
+    dryRun: false,
+    isCI: false,
+    verbose: false,
+    ...overrides,
+  }
+}
+
+describe('initHusky', () => {
+  let consoleWarnSpy
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    execSync.mockReturnValue('')
+    consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    consoleWarnSpy.mockRestore()
+    for (const dir of tempDirs) {
+      try {
+        rmSync(dir, { recursive: true, force: true })
+      } catch {
+        /* best-effort cleanup */
+      }
+    }
+    tempDirs.clear()
+  })
+
+  // ── 1. dry-run ───────────────────────────────────────────────────────────
+
+  it('dryRun: reports the planned action and touches nothing (wins over other flags)', async () => {
+    const dir = createConsumer()
+
+    const result = await initHusky(
+      makeContext(dir, { dryRun: true, isCI: true, hasGit: false }),
+    )
+
+    expect(result).toEqual({
+      action: 'dry-run',
+      message: 'Would initialize husky',
+    })
+    expect(info).toHaveBeenCalledWith(
+      '[setup] Would initialize husky (generate .husky/_/ shims, set core.hooksPath)',
+    )
+    expect(execSync).not.toHaveBeenCalled()
+    expect(existsSync(join(dir, '.husky'))).toBe(false)
+  })
+
+  // ── 2. CI ────────────────────────────────────────────────────────────────
+
+  it('CI environment: skips with a warning', async () => {
+    const dir = createConsumer()
+
+    const result = await initHusky(makeContext(dir, { isCI: true }))
+
+    expect(result).toEqual({
+      action: 'skipped',
+      message: 'Skipping husky init in CI environment',
+    })
+    expect(warn).toHaveBeenCalledWith(
+      '[setup] CI environment detected — skipping husky init',
+    )
+    expect(execSync).not.toHaveBeenCalled()
+  })
+
+  // ── 3. No git repository ────────────────────────────────────────────────
+
+  it('no .git directory: skips and warns on the console', async () => {
+    const dir = createConsumer()
+
+    const result = await initHusky(makeContext(dir, { hasGit: false }))
+
+    expect(result).toEqual({
+      action: 'skipped',
+      message: 'No .git directory — not a git repository',
+    })
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      '[setup] No .git directory — not a git repository',
+    )
+    expect(execSync).not.toHaveBeenCalled()
+  })
+
+  // ── 4. husky not installed ──────────────────────────────────────────────
+
+  it('husky not installed: skips with an install hint', async () => {
+    const dir = createConsumer({ husky: null })
+
+    const result = await initHusky(makeContext(dir))
+
+    expect(result.action).toBe('skipped')
+    expect(result.message).toContain('npm install husky --save-dev')
+    expect(verbose).toHaveBeenCalledWith(
+      false,
+      'husky not found — skipping init',
+    )
+    expect(execSync).not.toHaveBeenCalled()
+  })
+
+  // ── 5. husky import failure ─────────────────────────────────────────────
+
+  it('corrupt husky module: import throws, treated as not installed', async () => {
+    const dir = createConsumer({ husky: 'importThrows' })
+
+    const result = await initHusky(makeContext(dir))
+
+    expect(result.action).toBe('skipped')
+    expect(result.message).toContain('husky is not installed')
+  })
+
+  // ── 6. Success ───────────────────────────────────────────────────────────
+
+  it('success: clears core.hooksPath and verifies .husky/_/h', async () => {
+    const dir = createConsumer()
+
+    const result = await initHusky(makeContext(dir))
+
+    expect(result).toEqual({
+      action: 'initialized',
+      message: 'Husky initialized successfully',
+    })
+    expect(execSync).toHaveBeenCalledWith(
+      'git config --local --unset core.hooksPath',
+      { cwd: dir, stdio: 'pipe' },
+    )
+    expect(existsSync(join(dir, '.husky', '_', 'h'))).toBe(true)
+  })
+
+  // ── 7. Unset failure is swallowed ───────────────────────────────────────
+
+  it('unset failure: continues and still initializes', async () => {
+    const dir = createConsumer()
+    execSync.mockImplementation(() => {
+      throw new Error('key does not exist')
+    })
+
+    const result = await initHusky(makeContext(dir))
+
+    expect(result.action).toBe('initialized')
+    expect(existsSync(join(dir, '.husky', '_', 'h'))).toBe(true)
+  })
+
+  // ── 8. husky() throws ───────────────────────────────────────────────────
+
+  it('husky() throwing: returns action=failed with the error message', async () => {
+    const dir = createConsumer({ husky: 'throws' })
+
+    const result = await initHusky(makeContext(dir))
+
+    expect(result).toEqual({ action: 'failed', message: 'husky boom' })
+  })
+
+  // ── 9. Post-condition failure ───────────────────────────────────────────
+
+  it('post-condition: missing .husky/_/h returns action=failed', async () => {
+    const dir = createConsumer({ husky: 'noop' })
+
+    const result = await initHusky(makeContext(dir))
+
+    expect(result.action).toBe('failed')
+    expect(result.message).toContain('.husky/_/h not found after init')
+  })
+
+  // ── 10. Idempotency ─────────────────────────────────────────────────────
+
+  it('is idempotent: a second run still reports initialized', async () => {
+    const dir = createConsumer()
+
+    const first = await initHusky(makeContext(dir))
+    const second = await initHusky(makeContext(dir))
+
+    expect(first.action).toBe('initialized')
+    expect(second.action).toBe('initialized')
+    expect(existsSync(join(dir, '.husky', '_', 'h'))).toBe(true)
+  })
+
+  // ── 11. Verbose progress ────────────────────────────────────────────────
+
+  it('verbose: emits progress messages for each step', async () => {
+    const dir = createConsumer()
+
+    await initHusky(makeContext(dir, { verbose: true }))
+
+    const messages = verbose.mock.calls.map(([, message]) => message)
+    expect(verbose).toHaveBeenCalledWith(
+      true,
+      'Resolving husky from consumer node_modules…',
+    )
+    expect(messages).toContain('Clearing stale core.hooksPath…')
+    expect(messages).toContain('Calling husky()…')
+    expect(messages).toContain('Verifying .husky/_/h exists…')
+  })
+})