vibecoding-devtools 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Leonne Martins
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,46 @@
+# vibecoding-devtools
+
+Kit de rules, skills, hooks e modelos para desenvolvimento com IA em Claude Code, Codex e Antigravity. O esforço
+acompanha o risco: trocar um ícone leva minutos; mexer com dinheiro, contas ou segredos recebe contrato, testing e
+revisões.
+
+O kit integra o [ECC](https://github.com/affaan-m/ECC) e o [Impeccable](https://github.com/pbakaus/impeccable),
+instalados das fontes oficiais.
+
+## Instalação
+
+```bash
+npx vibecoding-devtools@1.0.1 install    # instala pelo painel
+npx vibecoding-devtools@1.0.1 update     # reutiliza as escolhas salvas
+npx vibecoding-devtools@1.0.1 uninstall  # remove só o que o kit instalou
+```
+
+Alternativa pelo GitHub: `npx github:Or4cu1o/vibecoding-devtools#v1.0.1 install` (aceita os mesmos comandos).
+
+Requer Node 22+ e git. O instalador detecta Claude Code, Codex e Antigravity, mostra o plano e só grava depois da
+confirmação. Use `--dry-run` para apenas conferir o plano. Detalhes no [guia do instalador](docs/installer.md).
+
+## Conteúdo
+
+| Pasta | O que tem |
+|---|---|
+| [`rules/`](rules/) | regras de risco, testes, modelos, contexto e uso do Maestri |
+| [`skills/`](skills/) | triagem de risco, revisão de segurança e operação do Maestri |
+| [`templates/`](templates/) | `AGENTS.md` e `CLAUDE.md` para projetos, e `.coderabbit.yaml` |
+| [Hooks](hooks/README.md) | `secret-scan`, `maestri-protocol` e `full-suite` implementados |
+| [`docs/`](docs/) | instalação, compatibilidade e justificativas das regras |
+
+O `secret-scan` verifica segredos com gitleaks antes de commits. O `maestri-protocol` valida mensagens e exige o pacote
+Maestri. O `full-suite` aplica um bloqueio contornável a suítes completas em repositórios com CI; para uma execução
+intencional, inclua `VIBECODING_FULL_SUITE=1` no comando.
+
+No escopo de projeto, os hooks são copiados para `.vibecoding-devtools/hooks/` dentro do repositório e registrados nos
+arquivos de projeto de cada CLI. Versione esses arquivos para toda a equipe receber os hooks. No Codex, cada pessoa
+os aprova uma vez em `/hooks`; mudanças nos hooks exigem nova aprovação.
+
+Consulte a [compatibilidade entre as CLIs](docs/cli-compatibility.md) e as
+[justificativas das regras](docs/rules-rationale.md).
+
+## Licença
+
+[MIT](LICENSE).

package/hooks/full-suite.mjs

@@ -0,0 +1,156 @@
+import { statSync, readdirSync, readFileSync } from 'node:fs';
+import { isAbsolute, resolve, dirname, win32 } from 'node:path';
+import { executable, isMain, runHook, shellCommands, windowsInput } from './lib/io.mjs';
+
+export const FULL_SUITE_REASON = 'CI runs the full suite; run only the tests for what you changed. If the full run is intended, repeat the command with VIBECODING_FULL_SUITE=1 in it.';
+
+// Only known non-filtering options are accepted. Unknown options may select tests.
+function optionsOnly(args, booleans = [], values = []) {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--') return i === args.length - 1;
+    if (booleans.includes(arg)) continue;
+    if (values.includes(arg)) {
+      if (!args[++i] || args[i].startsWith('-')) return false;
+      continue;
+    }
+    if (values.some(flag => arg.startsWith(`${flag}=`) && arg.length > flag.length + 1)) continue;
+    return false;
+  }
+  return true;
+}
+
+export function isFullSuite(words) {
+  words = [...words];
+  while (/^[A-Za-z_][A-Za-z_0-9]*=/.test(words[0] ?? '')) words.shift();
+  if (executable(words[0]) === 'env') {
+    words.shift();
+    while (/^[A-Za-z_][A-Za-z_0-9]*=/.test(words[0] ?? '')) words.shift();
+  }
+  const tool = executable(words.shift());
+  if (tool === 'node' && words[0] === '--test') {
+    return optionsOnly(words.slice(1), [], ['--test-reporter']);
+  }
+  if (tool === 'pytest' || tool === 'py.test') {
+    return optionsOnly(words, ['-q', '-qq', '-v', '-vv', '-s', '-x', '--verbose', '--quiet', '--exitfirst', '--disable-warnings', '--no-header', '--no-summary'], ['--maxfail', '--tb', '--color']);
+  }
+  if (['python', 'python3', 'py'].includes(tool) && words[0] === '-m' && words[1] === 'pytest') {
+    return isFullSuite(words.slice(1));
+  }
+  if (['npm', 'pnpm', 'yarn'].includes(tool)) {
+    if (words[0] === 'run') words.shift();
+    if (words.shift() !== 'test') return false;
+    if (words[0] === '--') words.shift();
+    return optionsOnly(words, ['--silent', '--verbose', '--runInBand', '--ci', '--coverage', '--watch=false', '--watchAll=false']);
+  }
+  if (tool === 'npx') return ['vitest', 'jest'].includes(executable(words[0])) && isFullSuite(words);
+  if (tool === 'vitest' || tool === 'jest') {
+    if (tool === 'vitest' && words.shift() === 'run') {
+      return optionsOnly(words, ['--coverage', '--silent', '--no-color'], ['--reporter']);
+    }
+    if (tool === 'jest') {
+      return optionsOnly(words, ['--runInBand', '--ci', '--coverage', '--silent', '--verbose', '--watch=false', '--watchAll=false', '--no-cache'], ['--maxWorkers']);
+    }
+    return false;
+  }
+  if (tool === 'go' && words.shift() === 'test') {
+    if (words.filter(word => word === './...').length !== 1) return false;
+    return optionsOnly(words.filter(word => word !== './...'), ['-v', '-race', '-cover', '-short', '-count=1'], ['-count', '-timeout', '-parallel']);
+  }
+  if (tool === 'cargo' && words.shift() === 'test') {
+    return optionsOnly(words, ['--workspace', '--all', '--all-targets', '--all-features', '--no-default-features', '--release', '--locked', '--offline', '--quiet', '-q', '--verbose', '-v']);
+  }
+  return false;
+}
+
+function exists(path, kind, fs) {
+  try { return fs.statSync(path)[kind](); }
+  catch (error) {
+    if (['ENOENT', 'ENOTDIR'].includes(error.code)) return false;
+    throw error;
+  }
+}
+
+const pathApi = cwd => win32.isAbsolute(cwd) && !cwd.startsWith('/') ? win32 : { resolve, dirname };
+
+function repositoryRoot(cwd, fs) {
+  const paths = pathApi(cwd);
+  if (!exists(cwd, 'isDirectory', fs)) return false;
+  let directory = paths.resolve(cwd);
+  while (true) {
+    if (exists(paths.resolve(directory, '.git'), 'isDirectory', fs)
+        || exists(paths.resolve(directory, '.git'), 'isFile', fs)) return directory;
+    const parent = paths.dirname(directory);
+    if (parent === directory) return null;
+    directory = parent;
+  }
+}
+
+function hasCI(directory, fs) {
+  const paths = pathApi(directory);
+  const workflows = paths.resolve(directory, '.github', 'workflows');
+  if (exists(workflows, 'isDirectory', fs)
+      && fs.readdirSync(workflows).some(file => /\.ya?ml$/i.test(file)
+        && exists(paths.resolve(workflows, file), 'isFile', fs))) return true;
+  if (['.gitlab-ci.yml', 'azure-pipelines.yml'].some(file => exists(paths.resolve(directory, file), 'isFile', fs))
+      || exists(paths.resolve(directory, '.circleci'), 'isDirectory', fs)) return true;
+  return false;
+}
+
+function packageSuite(words, cwd, windows, fs) {
+  // Scripts are data, never executed. Wrappers, chained scripts and lifecycle
+  // scripts leave scope uncertain, so only one supported literal runner denies.
+  const packageJson = JSON.parse(fs.readFileSync(pathApi(cwd).resolve(cwd, 'package.json'), 'utf8'));
+  const scripts = packageJson?.scripts;
+  if (typeof scripts?.test !== 'string' || scripts.pretest || scripts.posttest) return false;
+  const commands = shellCommands(scripts.test, { windows });
+  if (commands?.length !== 1) return false;
+  const script = commands[0];
+  const runner = executable(script[0]);
+  if (['npm', 'pnpm', 'yarn', 'env'].includes(runner) || /^[A-Za-z_][A-Za-z_0-9]*=/.test(script[0])) return false;
+  let args = words.slice(1);
+  if (args[0] === 'run') args.shift();
+  args.shift(); // test
+  if (args[0] === '--') args.shift();
+  return isFullSuite([...script, ...args]);
+}
+
+export function checkFullSuite(input, { fs = { statSync, readdirSync, readFileSync } } = {}) {
+  try {
+    if (typeof input.command !== 'string') return;
+    if (typeof input.cwd !== 'string' || !(isAbsolute(input.cwd) || win32.isAbsolute(input.cwd))) return;
+    if (/^\\(?!\\)/.test(input.cwd)
+        || (/^\\\\/.test(input.cwd) && !/^\\\\[^\\]+\\[^\\]+(?:\\|$)/.test(input.cwd))) return;
+    const windows = windowsInput(input);
+    // Normalize only literal PowerShell override assignments. Other expansion
+    // remains unsupported and fails open in the shared parser.
+    const literal = input.command.replace(/(^|[;\n])\s*\$env:VIBECODING_FULL_SUITE\s*=\s*(?:'([0-9]+)'|"([0-9]+)"|([0-9]+))(?=\s*(?:[;\n]|$))/g,
+      (_, boundary, single, double, bare) => `${boundary} VIBECODING_FULL_SUITE=${single ?? double ?? bare}`);
+    const commands = shellCommands(literal, { windows });
+    if (!commands) return;
+    for (const words of commands) {
+      if (executable(words[0]) === 'set' && words.length === 2 && /^VIBECODING_FULL_SUITE=[0-9]+$/.test(words[1])) words.shift();
+    }
+    if (commands.some(words => words.includes('VIBECODING_FULL_SUITE=1'))) return;
+    if (commands.some(words => ['cd', 'chdir', 'set-location', 'push-location', 'pop-location', 'sl', 'pushd', 'popd', 'export', 'set', 'unset', 'source', '.']
+      .includes(executable(words[0])))) return;
+    const candidates = commands.filter(isFullSuite);
+    if (!candidates.length) return;
+    const root = repositoryRoot(input.cwd, fs);
+    // A runner below the repository root may cover only one monorepo package.
+    if (!root || root !== pathApi(input.cwd).resolve(input.cwd) || !hasCI(root, fs)) return;
+    for (const words of candidates) {
+      // Strip literal environment prefixes consistently before inspecting scripts.
+      const invocation = [...words];
+      while (/^[A-Za-z_][A-Za-z_0-9]*=/.test(invocation[0] ?? '')) invocation.shift();
+      if (executable(invocation[0]) === 'env') {
+        invocation.shift();
+        while (/^[A-Za-z_][A-Za-z_0-9]*=/.test(invocation[0] ?? '')) invocation.shift();
+      }
+      if (!['npm', 'pnpm', 'yarn'].includes(executable(invocation[0]))
+          || packageSuite(invocation, input.cwd, windows, fs)) return FULL_SUITE_REASON;
+    }
+  } catch { /* Uncertain commands or inaccessible repository metadata allow. */ }
+}
+
+if (isMain(import.meta.url)) process.exitCode = await runHook(checkFullSuite);

package/hooks/lib/io.mjs

@@ -0,0 +1,135 @@
+import { resolve, isAbsolute, win32 } from 'node:path';
+import { realpathSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
+
+export function parseInput(text) {
+  try {
+    const input = JSON.parse(text);
+    if (typeof input?.toolCall?.name === 'string') {
+      const args = input.toolCall.args;
+      // 1.5.2 omits Cwd when using the sole workspace as the default directory.
+      // Multiple workspaces or invalid paths do not establish a safe default.
+      const workspace = Array.isArray(input.workspacePaths) && input.workspacePaths.length === 1
+        ? input.workspacePaths[0] : undefined;
+      const defaultCwd = typeof workspace === 'string' && (isAbsolute(workspace) || win32.isAbsolute(workspace))
+        ? workspace : undefined;
+      return { cli: 'antigravity', command: input.toolCall.name === 'run_command'
+        && typeof args?.CommandLine === 'string' ? args.CommandLine : undefined,
+        cwd: args?.Cwd === undefined ? defaultCwd : args.Cwd, shell: args?.Shell ?? input.shell };
+    }
+    if (['Bash', 'PowerShell'].includes(input?.tool_name)
+        && typeof input?.tool_input?.command === 'string') {
+      // turn_id is a Codex-specific PreToolUse field; Claude also reports Bash.
+      return { cli: typeof input.turn_id === 'string' ? 'codex' : 'claude-codex',
+        command: input.tool_input.command, cwd: input.cwd,
+        shell: input.tool_name === 'PowerShell' ? 'PowerShell' : input.shell };
+    }
+  } catch { /* Invalid JSON is an uncertain input, so allow it. */ }
+  return null;
+}
+
+export function respond(input, reason, { stdout = process.stdout, stderr = process.stderr } = {}) {
+  if (input?.cli === 'antigravity') {
+    stdout.write(`${JSON.stringify(reason ? { decision: 'deny', reason } : { decision: 'allow' })}\n`);
+    return 0;
+  }
+  if (input && reason) {
+    if (input.cli === 'codex') {
+      // PowerShell -Command maps a native exit 2 to exit 1. JSON denial with
+      // success survives that wrapper and is supported by Codex PreToolUse.
+      stdout.write(`${JSON.stringify({ hookSpecificOutput: { hookEventName: 'PreToolUse',
+        permissionDecision: 'deny', permissionDecisionReason: reason } })}\n`);
+      return 0;
+    }
+    stderr.write(`${reason}\n`);
+    return 2;
+  }
+  return 0;
+}
+
+export async function runHook(check, {
+  stdin = process.stdin, stdout = process.stdout, stderr = process.stderr,
+} = {}) {
+  let input = null;
+  let reason;
+  try {
+    let text = '';
+    for await (const chunk of stdin) text += chunk;
+    input = parseInput(text);
+    if (typeof input?.command === 'string') reason = await check(input, { stderr });
+  } catch { /* A hook must never deny because of its own failure. */ }
+  return respond(input, reason, { stdout, stderr });
+}
+
+export function isMain(url) {
+  if (!process.argv[1]) return false;
+  let entryPath = resolve(process.argv[1]);
+  try { entryPath = realpathSync(entryPath); } catch { /* Keep the resolved path if it cannot be read. */ }
+  return pathToFileURL(entryPath).href === url;
+}
+
+export function executable(token) {
+  return token?.split(/[\\/]/).at(-1).replace(/\.(exe|cmd|bat)$/i, '').toLowerCase();
+}
+
+export function windowsInput(input) {
+  return process.platform === 'win32'
+    || /^(powershell|pwsh|cmd)(?:\.exe)?$/i.test(executable(input.shell))
+    || /^(?:[a-z]:|\\\\)/i.test(input.cwd ?? '')
+    || /(?:[a-z]:\\|\\\\[^\\\s]+\\)/i.test(input.command ?? '');
+}
+
+// Deliberately parse only literal shell words. No expansion or shell execution.
+// Unsupported syntax returns null, making hooks fail open.
+export function shellCommands(command, { windows = process.platform === 'win32' } = {}) {
+  const commands = [];
+  let words = [];
+  let word = '';
+  let started = false;
+  let quote = null;
+  const pushWord = () => {
+    if (started) words.push(word);
+    word = '';
+    started = false;
+  };
+  const pushCommand = () => {
+    pushWord();
+    if (words.length) commands.push(words);
+    words = [];
+  };
+  for (let i = 0; i < command.length; i++) {
+    const char = command[i];
+    if (quote) {
+      if (char === quote) {
+        // Doubled single quotes are ambiguous between PowerShell and Bash.
+        if (quote === "'" && command[i + 1] === "'") return null;
+        quote = null;
+      } else if (quote === '"' && /[$`%]/.test(char)) return null;
+      else if (!windows && quote === '"' && char === '\\' && /["\\$`]/.test(command[i + 1] ?? '')) {
+        word += command[++i];
+      } else word += char;
+      continue;
+    }
+    if (/[$`%(){}<>^]/.test(char) || (char === '@' && /['"]/.test(command[i + 1] ?? ''))) return null;
+    if (char === '"' || char === "'") {
+      quote = char;
+      started = true;
+    } else if (!windows && char === '\\') {
+      if (i + 1 === command.length) return null;
+      const next = command[i + 1];
+      if (next === '\n') i++;
+      else if (/[\s'"\\;&|]/.test(next)) { word += next; i++; started = true; }
+      else { word += char; started = true; }
+    } else if (/[;&|\n]/.test(char)) pushCommand();
+    else if (/\s/.test(char)) pushWord();
+    else if (char === '#' && !started) {
+      while (i < command.length && command[i] !== '\n') i++;
+      pushCommand();
+    } else { word += char; started = true; }
+  }
+  if (quote) return null;
+  pushCommand();
+  // Literal command lists do not model shell blocks or conditional execution.
+  if (commands.some(words => /^(?:if|then|else|elif|fi|for|foreach|while|do|done|until|switch|case|esac|function|filter|try|catch|finally|begin|process|end|trap|class)$/i.test(words[0]))) return null;
+  return commands;
+}

package/hooks/maestri-protocol.mjs

@@ -0,0 +1,48 @@
+import { executable, isMain, runHook, shellCommands, windowsInput } from './lib/io.mjs';
+
+const header = /^~ (?<name>[^|\n]+?) \| (?<status>DONE|PENDING|BLOCKED|ERROR|ACK|ASK) \| (?<ref>[^|\n]+?) \| (?<summary>[^\n]+)$/;
+const reason = 'Maestri message must use a valid protocol header or end with the delegation footer.';
+
+export function validMessage(message) {
+  const text = message.replace(/\r\n/g, '\n');
+  if (text.startsWith('~')) return header.test(text.split('\n')[0]);
+  // Match the skill footer at the end, including its report-back instruction.
+  const footer = text.match(/(?:^|\n)ref: ([^\n]+)\nWhen done, load the maestri-protocol skill and report back with:\nmaestri ask "([^"\n]+)" "~ ([^|\n]+?) \| STATUS \| ([^|\n]+?) \| one-line summary"\nSTATUS is one of DONE, PENDING, BLOCKED, ERROR, ACK\. Details go on the following lines\.\s*$/);
+  return Boolean(footer && footer[1] === footer[4]);
+}
+
+function messages(words) {
+  if (words.includes('--raw')) return null;
+  if (words[0] === '--batch' && words.length === 2) {
+    try {
+      const batch = JSON.parse(words[1]);
+      if (!batch || typeof batch !== 'object' || Array.isArray(batch)) return null;
+      const values = Object.values(batch);
+      return values.every(value => typeof value === 'string') ? values : null;
+    } catch { return null; }
+  }
+  // Unknown flags or arity are uncertain; do not guess which word is the message.
+  if (words.length === 2 && words.every(word => !word.startsWith('--'))) return [decodeMessage(words[1])];
+  return null;
+}
+
+export function decodeMessage(message) {
+  return message.replace(/\\(n|t|e|x[0-9a-fA-F]{2})/g, (_, escape) => {
+    if (escape === 'n') return '\n';
+    if (escape === 't') return '\t';
+    if (escape === 'e') return '\x1b';
+    return String.fromCharCode(Number.parseInt(escape.slice(1), 16));
+  });
+}
+
+export function checkMaestriProtocol(input) {
+  const commands = shellCommands(input.command, { windows: windowsInput(input) });
+  if (!commands) return;
+  for (const words of commands) {
+    if (executable(words[0]) !== 'maestri' || words[1] !== 'ask') continue;
+    const extracted = messages(words.slice(2));
+    if (extracted?.some(message => !validMessage(message))) return reason;
+  }
+}
+
+if (isMain(import.meta.url)) process.exitCode = await runHook(checkMaestriProtocol);

package/hooks/secret-scan.mjs

@@ -0,0 +1,90 @@
+import { spawnSync } from 'node:child_process';
+import { isAbsolute, resolve, win32 } from 'node:path';
+import { executable, isMain, runHook, shellCommands, windowsInput } from './lib/io.mjs';
+
+const scanFlags = ['--redact', '--no-banner', '--exit-code', '99'];
+export const GITLEAKS_ARGS = ['git', '--pre-commit', '--staged', ...scanFlags];
+const leakReason = 'Commit blocked: changes that can enter the commit contain secrets. Remove them before committing.';
+const warning = 'Secret scan unavailable; allowing command.\n';
+
+function commitDirectory(words, cwd, windows) {
+  if (executable(words[0]) !== 'git') return null;
+  let directory = cwd;
+  for (let i = 1; i < words.length; i++) {
+    const arg = words[i];
+    if (arg === 'commit') return directory;
+    if (arg === '-C' || arg.startsWith('-C')) {
+      const value = arg === '-C' ? words[++i] : arg.slice(2);
+      if (value === undefined) return null;
+      // A drive-relative or incomplete UNC path cannot be resolved safely from
+      // the supplied cwd. Never let Node fill in another drive's process cwd.
+      if (windows && (/^[a-z]:(?![\\/])/i.test(value)
+          || (/^\\\\/.test(value) && !/^\\\\[^\\]+\\[^\\]+(?:\\|$)/.test(value))
+          || (/^\\(?!\\)/.test(value) && !/^[a-z]:/i.test(directory)))) return null;
+      directory = /^(?:[a-z]:[\\/]|\\\\)/i.test(directory) || /^(?:[a-z]:[\\/]|\\\\)/i.test(value)
+        ? win32.resolve(directory, value) : resolve(directory, value);
+    } else if (arg === '-c' || arg === '--config-env') {
+      if (words[++i] === undefined) return null;
+    } else if (arg.startsWith('-c') || arg.startsWith('--config-env=')
+        || ['--no-pager', '--paginate', '--literal-pathspecs', '--no-optional-locks', '--bare'].includes(arg)) {
+      continue;
+    } else return null;
+  }
+  return null;
+}
+
+export function checkSecretScan(input, { runner = spawnSync, stderr = process.stderr } = {}) {
+  const windows = windowsInput(input);
+  const commands = shellCommands(input.command, { windows });
+  if (!commands) return;
+  // Earlier commands can change repository selection. Without evaluating their
+  // control flow, the effective cwd/environment cannot be established reliably.
+  if (commands.some(words => ['cd', 'chdir', 'set-location', 'pushd', 'popd', 'export', 'set', 'unset']
+    .includes(executable(words[0])))) return;
+  if (typeof input.cwd !== 'string' || !(isAbsolute(input.cwd) || win32.isAbsolute(input.cwd))) return;
+  if (windows && (/^\\(?!\\)/.test(input.cwd)
+      || (/^\\\\/.test(input.cwd) && !/^\\\\[^\\]+\\[^\\]+(?:\\|$)/.test(input.cwd)))) return;
+  let warned = false;
+  const warn = () => {
+    if (!warned) {
+      stderr.write(warning);
+      warned = true;
+    }
+  };
+  const run = (command, args, cwd) => {
+    try {
+      return runner(command, args, {
+        cwd, encoding: 'utf8', stdio: 'pipe', timeout: 5000, windowsHide: true,
+      });
+    } catch { return undefined; }
+  };
+  const scan = (args, cwd) => {
+    const result = run('gitleaks', args, cwd);
+    if (!result?.error && !result?.signal && result?.status === 99) return true;
+    if (result?.error || result?.signal || result?.status !== 0) warn();
+    return false;
+  };
+  for (const words of commands) {
+    const cwd = commitDirectory(words, input.cwd, windows);
+    if (!cwd) continue;
+    if (scan([...GITLEAKS_ARGS], cwd)) return leakReason;
+    if (scan(['git', '--pre-commit', ...scanFlags], cwd)) return leakReason;
+    const listing = run('git', ['ls-files', '--others', '--exclude-standard', '-z'], cwd);
+    if (listing?.error || listing?.signal || listing?.status !== 0 || typeof listing?.stdout !== 'string') {
+      warn();
+      continue;
+    }
+    // NUL delimiters preserve spaces, quotes and newlines in Git filenames.
+    if (listing.stdout && !listing.stdout.endsWith('\0')) { warn(); continue; }
+    for (const file of listing.stdout.split('\0').filter(Boolean)) {
+      const paths = win32.isAbsolute(cwd) && !cwd.startsWith('/') ? win32 : { resolve, isAbsolute };
+      const target = paths.resolve(cwd, file);
+      // Git lists relative files. Reject unexpected absolute/traversal output.
+      if (paths.isAbsolute(file) || /^[a-z]:/i.test(file)
+          || file.split(/[\\/]/).includes('..')) { warn(); continue; }
+      if (scan(['dir', target, ...scanFlags], cwd)) return leakReason;
+    }
+  }
+}
+
+if (isMain(import.meta.url)) process.exitCode = await runHook(checkSecretScan);