fix(uncheck): write the pre-commit hook husky 9 and Vite+ actually run (#9)

Author: dinwwwh

packages/uncheck/README.md

@@ -132,7 +132,7 @@ npx uncheck prepare --pre-commit   # write .git/hooks/pre-commit so every commit
 
 `staged` runs the checks on the files staged for commit. The unstaged hunks of partially staged files (`git add -p`) are set aside while the checks run, so what `oxlint` and `oxfmt` see is what gets committed, then put back. The typecheck works differently by nature: `tsc` checks whole projects, so it also reports type errors in files you have not staged. Add `--only=oxlint --only=oxfmt` for a hook that never looks beyond the commit. With `--fix` the fixes are staged too. When a fix conflicts with an unstaged hunk, the fixes are undone and the commit fails, so nothing is ever lost: stage the whole file or stash its unstaged changes and commit again. A run killed before it puts them back leaves copies of the files in the git directory, and the next run stops and says where they are.
 
-`prepare --pre-commit` replaces lint-staged and simple-git-hooks: it writes the git hook itself, running `uncheck staged --fix` through your package manager, and adds itself to an existing `pre-commit` hook rather than replacing it. Running it again only ever rewrites the line it wrote itself, so lines you added by hand stay, a repeated copy of its own line is dropped, and in a monorepo each package that prepares gets its own line with its own flags. Without a flag `prepare` sets nothing up. Register it as the `prepare` script so every clone installs the hook:
+`prepare --pre-commit` replaces lint-staged and simple-git-hooks: it writes the git hook itself, running `uncheck staged --fix` through your package manager, and adds itself to an existing `pre-commit` hook rather than replacing it. With husky 9 or Vite+ (`vp config`) managing the hooks, it writes to `.husky/pre-commit` or `.vite-hooks/pre-commit`, the file their dispatcher runs, rather than to the generated shim in `_/`, which never reaches an added line and is rewritten on the next install. Running it again only ever rewrites the line it wrote itself, so lines you added by hand stay, a repeated copy of its own line is dropped, and in a monorepo each package that prepares gets its own line with its own flags. Without a flag `prepare` sets nothing up. Register it as the `prepare` script so every clone installs the hook:
 
 ```json
 {

packages/uncheck/src/commands/prepare.ts

@@ -109,7 +109,13 @@ export const prepare = Command.make(
     const inside = path.relative(top!, yield* fs.realPath(cwd)).replaceAll('\\', '/')
     const line = hookLine(inside, command)
 
-    const file = path.join(path.resolve(cwd, hooks!), 'pre-commit')
+    // husky 9 and Vite+ point core.hooksPath at generated shims that source the `h` dispatcher, which
+    // exits before any line appended to a shim and runs the hook in the folder above instead.
+    const configured = path.resolve(cwd, hooks!)
+    const dispatched = yield* fs
+      .exists(path.join(configured, 'h'))
+      .pipe(Effect.orElseSucceed(() => false))
+    const file = path.join(dispatched ? path.dirname(configured) : configured, 'pre-commit')
     const relative = path.relative(cwd, file)
     const shown = relative.startsWith('..') ? file : relative
     const existing = yield* fs.readFileString(file).pipe(Effect.option)
@@ -128,7 +134,11 @@ export const prepare = Command.make(
         yield* fs.writeFileString(file, next)
       }
 
-      yield* fs.chmod(file, 0o755)
+      // The dispatcher runs the hook with `sh`, and flipping the mode of a committed hook would leave
+      // every clone with a change to commit.
+      if (!dispatched) {
+        yield* fs.chmod(file, 0o755)
+      }
     }).pipe(
       Effect.as(undefined),
       Effect.catch((error) =>

packages/uncheck/tests/command.test.ts

@@ -1414,6 +1414,146 @@ describe('uncheck prepare', { timeout: 120_000 }, () => {
     expect(skipped.result).toBe('ok')
     expect(skipped.stdout).toBe('○ no git repository found, nothing to prepare\n')
   })
+
+  it('writes the hook the husky 9 and Vite+ dispatcher runs, not their generated shim', async () => {
+    const dispatcher = [
+      's="$(dirname "$(dirname "$0")")/$(basename "$0")"',
+      '[ ! -f "$s" ] && exit 0',
+      'export PATH="node_modules/.bin:$PATH"',
+      'sh -e "$s" "$@"',
+      'exit $?',
+      '',
+    ].join('\n')
+    const shim = '#!/usr/bin/env sh\n. "$(dirname "$0")/h"\n'
+    const dir = fixture(
+      {
+        'package.json': '{}\n',
+        'pnpm-lock.yaml': '',
+        'packages/app/package.json': '{}\n',
+        '.husky/_/h': dispatcher,
+        '.husky/_/pre-commit': shim,
+        '.husky/pre-commit': 'pnpm test\n',
+      },
+      [],
+    )
+    gitIn(dir, 'init', '--quiet')
+    gitIn(dir, 'config', 'core.hooksPath', '.husky/_')
+    chmodSync(join(dir, '.husky/_/pre-commit'), 0o755)
+    const hook = join(dir, '.husky/pre-commit')
+    const app = '(cd "packages/app" && pnpm exec uncheck staged --fix --only=oxlint) || exit 1'
+
+    const { result, stdout } = await run(dir, ['prepare', '--pre-commit'])
+
+    expect(result).toBe('ok')
+    expect(stdout).toContain('✔ pre-commit .husky/pre-commit updated\n')
+
+    const nested = await run(join(dir, 'packages/app'), [
+      'prepare',
+      '--pre-commit',
+      '--only=oxlint',
+    ])
+
+    expect(nested.stdout).toContain(`✔ pre-commit ${hook} updated\n`)
+    expect(readFileSync(hook, 'utf8')).toBe(
+      `pnpm test\npnpm exec uncheck staged --fix || exit 1\n${app}\n`,
+    )
+    expect(readFileSync(join(dir, '.husky/_/pre-commit'), 'utf8')).toBe(shim)
+
+    const again = await run(dir, ['prepare', '--pre-commit'])
+
+    expect(again.stdout).toContain('✔ pre-commit .husky/pre-commit unchanged\n')
+
+    if (process.platform !== 'win32') {
+      expect(statSync(hook).mode & 0o111).toBe(0)
+
+      const bin = fixture(
+        { pnpm: '#!/bin/sh\necho "$(pwd -P) $*" >> "$LOG"\ntest ! -e fail\n' },
+        [],
+      )
+      const log = join(bin, 'log')
+      chmodSync(join(bin, 'pnpm'), 0o755)
+
+      function commit() {
+        writeFileSync(log, '')
+
+        const { status } = spawnSync(
+          'git',
+          [
+            '-c',
+            'user.name=uncheck',
+            '-c',
+            'user.email=uncheck@example.com',
+            'commit',
+            '--allow-empty',
+            '--quiet',
+            '--message=test',
+          ],
+          {
+            cwd: dir,
+            env: { ...process.env, PATH: `${bin}${delimiter}${process.env.PATH}`, LOG: log },
+          },
+        )
+
+        return { status, ran: readFileSync(log, 'utf8').split('\n').filter(Boolean) }
+      }
+
+      const top = realpathSync(dir)
+
+      expect(commit()).toEqual({
+        status: 0,
+        ran: [
+          `${top} test`,
+          `${top} exec uncheck staged --fix`,
+          `${top}/packages/app exec uncheck staged --fix --only=oxlint`,
+        ],
+      })
+
+      writeFileSync(join(dir, 'fail'), '')
+
+      expect(commit()).toEqual({ status: 1, ran: [`${top} test`] })
+    }
+
+    const vite = fixture(
+      { 'package.json': '{}\n', 'pnpm-lock.yaml': '', '.vite-hooks/_/h': dispatcher },
+      [],
+    )
+    gitIn(vite, 'init', '--quiet')
+    gitIn(vite, 'config', 'core.hooksPath', '.vite-hooks/_')
+
+    const created = await run(vite, ['prepare', '--pre-commit'])
+
+    expect(created.stdout).toContain('✔ pre-commit .vite-hooks/pre-commit created\n')
+    expect(readFileSync(join(vite, '.vite-hooks/pre-commit'), 'utf8')).toBe(
+      `${header}pnpm exec uncheck staged --fix || exit 1\n`,
+    )
+    expect(existsSync(join(vite, '.vite-hooks/_/pre-commit'))).toBe(false)
+  })
+
+  it('writes into a core.hooksPath set by hand as it is', async () => {
+    const dir = fixture(
+      { 'package.json': '{}\n', 'pnpm-lock.yaml': '', 'packages/app/package.json': '{}\n' },
+      [],
+    )
+    gitIn(dir, 'init', '--quiet')
+    gitIn(dir, 'config', 'core.hooksPath', '.githooks')
+    const hook = join(dir, '.githooks/pre-commit')
+
+    const { result, stdout } = await run(dir, ['prepare', '--pre-commit'])
+
+    expect(result).toBe('ok')
+    expect(stdout).toContain('✔ pre-commit .githooks/pre-commit created\n')
+
+    await run(join(dir, 'packages/app'), ['prepare', '--pre-commit'])
+
+    expect(readFileSync(hook, 'utf8')).toBe(
+      `${header}pnpm exec uncheck staged --fix || exit 1\n(cd "packages/app" && pnpm exec uncheck staged --fix) || exit 1\n`,
+    )
+    expect(existsSync(join(dir, '.git/hooks/pre-commit'))).toBe(false)
+
+    if (process.platform !== 'win32') {
+      expect(statSync(hook).mode & 0o111).toBe(0o111)
+    }
+  })
 })
 
 describe('uncheck presets', { timeout: 120_000 }, () => {