claude-auto 0.12.4

package/dist/src/commit-validator.test.js

@@ -0,0 +1,733 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const vitest_1 = require("vitest");
+const commit_validator_js_1 = require("./commit-validator.js");
+function claudeJson(inner) {
+    return JSON.stringify({ type: 'result', subtype: 'success', result: JSON.stringify(inner) });
+}
+function claudeBatchJson(results) {
+    return JSON.stringify({ type: 'result', subtype: 'success', result: JSON.stringify(results) });
+}
+(0, vitest_1.describe)('extractAppeal', () => {
+    (0, vitest_1.it)('extracts appeal from commit message with [appeal: reason]', () => {
+        const message = 'feat: add feature [appeal: coherence]';
+        const result = (0, commit_validator_js_1.extractAppeal)(message);
+        (0, vitest_1.expect)(result).toBe('coherence');
+    });
+    (0, vitest_1.it)('returns null when no appeal present', () => {
+        const message = 'feat: add feature';
+        const result = (0, commit_validator_js_1.extractAppeal)(message);
+        (0, vitest_1.expect)(result).toBe(null);
+    });
+});
+(0, vitest_1.describe)('isCommitCommand', () => {
+    (0, vitest_1.it)('detects simple git commit', () => {
+        (0, vitest_1.expect)((0, commit_validator_js_1.isCommitCommand)('git commit -m "message"')).toBe(true);
+    });
+    (0, vitest_1.it)('detects git commit with add', () => {
+        (0, vitest_1.expect)((0, commit_validator_js_1.isCommitCommand)('git add -A && git commit -m "message"')).toBe(true);
+    });
+    (0, vitest_1.it)('detects git commit with heredoc', () => {
+        (0, vitest_1.expect)((0, commit_validator_js_1.isCommitCommand)('git commit -m "$(cat <<\'EOF\'\nmessage\nEOF\n)"')).toBe(true);
+    });
+    (0, vitest_1.it)('returns false for git status', () => {
+        (0, vitest_1.expect)((0, commit_validator_js_1.isCommitCommand)('git status')).toBe(false);
+    });
+    (0, vitest_1.it)('returns false for git diff', () => {
+        (0, vitest_1.expect)((0, commit_validator_js_1.isCommitCommand)('git diff')).toBe(false);
+    });
+    (0, vitest_1.it)('returns false for non-git commands', () => {
+        (0, vitest_1.expect)((0, commit_validator_js_1.isCommitCommand)('npm test')).toBe(false);
+    });
+});
+(0, vitest_1.describe)('getCommitContext', () => {
+    let tempDir;
+    (0, vitest_1.beforeEach)(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ketchup-commit-'));
+    });
+    (0, vitest_1.afterEach)(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    (0, vitest_1.it)('extracts diff, files, and message from staged changes', () => {
+        const { execSync } = require('node:child_process');
+        execSync('git init', { cwd: tempDir, stdio: 'pipe' });
+        execSync('git config user.email "test@test.com"', { cwd: tempDir, stdio: 'pipe' });
+        execSync('git config user.name "Test"', { cwd: tempDir, stdio: 'pipe' });
+        fs.writeFileSync(path.join(tempDir, 'test.txt'), 'hello world');
+        execSync('git add test.txt', { cwd: tempDir, stdio: 'pipe' });
+        const result = (0, commit_validator_js_1.getCommitContext)(tempDir, 'git commit -m "Add test file"');
+        (0, vitest_1.expect)(result).toEqual({
+            diff: vitest_1.expect.stringContaining('+hello world'),
+            files: ['test.txt'],
+            message: 'Add test file',
+        });
+    });
+    (0, vitest_1.it)('returns empty message when no -m flag present', () => {
+        const { execSync } = require('node:child_process');
+        execSync('git init', { cwd: tempDir, stdio: 'pipe' });
+        execSync('git config user.email "test@test.com"', { cwd: tempDir, stdio: 'pipe' });
+        execSync('git config user.name "Test"', { cwd: tempDir, stdio: 'pipe' });
+        fs.writeFileSync(path.join(tempDir, 'test.txt'), 'hello');
+        execSync('git add test.txt', { cwd: tempDir, stdio: 'pipe' });
+        const result = (0, commit_validator_js_1.getCommitContext)(tempDir, 'git commit');
+        (0, vitest_1.expect)(result).toEqual({
+            diff: vitest_1.expect.stringContaining('+hello'),
+            files: ['test.txt'],
+            message: '',
+        });
+    });
+    (0, vitest_1.it)('uses cd target from command when cwd is a non-repo parent', () => {
+        // Previously this threw because getCommitContext ran git diff --cached
+        // in the parent dir (not a repo). Now it extracts the cd target.
+        const { execSync } = require('node:child_process');
+        const parentDir = tempDir; // not a git repo
+        const repoDir = path.join(parentDir, 'sub-repo');
+        fs.mkdirSync(repoDir);
+        execSync('git init', { cwd: repoDir, stdio: 'pipe' });
+        execSync('git config user.email "test@test.com"', { cwd: repoDir, stdio: 'pipe' });
+        execSync('git config user.name "Test"', { cwd: repoDir, stdio: 'pipe' });
+        fs.writeFileSync(path.join(repoDir, 'file.ts'), 'const x = 1;');
+        execSync('git add file.ts', { cwd: repoDir, stdio: 'pipe' });
+        const command = `cd ${repoDir} && git add file.ts && git commit -m "test: no-op"`;
+        const result = (0, commit_validator_js_1.getCommitContext)(parentDir, command);
+        (0, vitest_1.expect)(result).toEqual({
+            diff: vitest_1.expect.stringContaining('+const x = 1;'),
+            files: ['file.ts'],
+            message: 'test: no-op',
+        });
+    });
+});
+(0, vitest_1.describe)('extractCdTarget', () => {
+    (0, vitest_1.it)('extracts path from cd command', () => {
+        (0, vitest_1.expect)((0, commit_validator_js_1.extractCdTarget)('cd /foo/bar && git commit -m "msg"')).toBe('/foo/bar');
+    });
+    (0, vitest_1.it)('returns null when no cd prefix', () => {
+        (0, vitest_1.expect)((0, commit_validator_js_1.extractCdTarget)('git commit -m "msg"')).toBe(null);
+    });
+    (0, vitest_1.it)('extracts path when cd is followed by &&', () => {
+        (0, vitest_1.expect)((0, commit_validator_js_1.extractCdTarget)('cd /a/b/c && git add . && git commit -m "x"')).toBe('/a/b/c');
+    });
+});
+(0, vitest_1.describe)('parseClaudeJsonOutput', () => {
+    (0, vitest_1.it)('extracts inner result and total token usage from claude json wrapper', () => {
+        const stdout = JSON.stringify({
+            type: 'result',
+            subtype: 'success',
+            result: '{"decision":"ACK"}',
+            usage: { input_tokens: 3, output_tokens: 9, cache_read_input_tokens: 21684, cache_creation_input_tokens: 6728 },
+        });
+        const parsed = (0, commit_validator_js_1.parseClaudeJsonOutput)(stdout);
+        (0, vitest_1.expect)(parsed).toEqual({ decision: 'ACK', inputTokens: 28415, outputTokens: 9 });
+    });
+    (0, vitest_1.it)('extracts NACK with reason and tokens from wrapper', () => {
+        const stdout = JSON.stringify({
+            type: 'result',
+            subtype: 'success',
+            result: '{"decision":"NACK","reason":"Missing tests"}',
+            usage: { input_tokens: 150, output_tokens: 12 },
+        });
+        const parsed = (0, commit_validator_js_1.parseClaudeJsonOutput)(stdout);
+        (0, vitest_1.expect)(parsed).toEqual({ decision: 'NACK', reason: 'Missing tests', inputTokens: 150, outputTokens: 12 });
+    });
+    (0, vitest_1.it)('returns outer object when result is not a string', () => {
+        const stdout = '{"decision":"ACK"}';
+        const parsed = (0, commit_validator_js_1.parseClaudeJsonOutput)(stdout);
+        (0, vitest_1.expect)(parsed).toEqual({ decision: 'ACK' });
+    });
+    (0, vitest_1.it)('defaults to NACK when decision is missing', () => {
+        const stdout = JSON.stringify({
+            type: 'result',
+            subtype: 'success',
+            result: '{"some":"garbage"}',
+        });
+        const parsed = (0, commit_validator_js_1.parseClaudeJsonOutput)(stdout);
+        (0, vitest_1.expect)(parsed).toEqual({ decision: 'NACK', reason: 'validator returned invalid response (no ACK decision)' });
+    });
+    (0, vitest_1.it)('defaults to NACK when decision is not ACK or NACK', () => {
+        const stdout = JSON.stringify({
+            type: 'result',
+            subtype: 'success',
+            result: '{"decision":"MAYBE"}',
+        });
+        const parsed = (0, commit_validator_js_1.parseClaudeJsonOutput)(stdout);
+        (0, vitest_1.expect)(parsed).toEqual({ decision: 'NACK', reason: 'validator returned invalid response (no ACK decision)' });
+    });
+    (0, vitest_1.it)('defaults to NACK when inner result is not valid JSON', () => {
+        const stdout = JSON.stringify({
+            type: 'result',
+            subtype: 'success',
+            result: 'just some text response',
+        });
+        const parsed = (0, commit_validator_js_1.parseClaudeJsonOutput)(stdout);
+        (0, vitest_1.expect)(parsed).toEqual({ decision: 'NACK', reason: 'validator returned invalid response (no ACK decision)' });
+    });
+});
+(0, vitest_1.describe)('parseBatchedOutput', () => {
+    (0, vitest_1.it)('parses valid batched JSON array from claude envelope', () => {
+        const stdout = claudeBatchJson([
+            { id: 'coverage-rules', decision: 'ACK' },
+            { id: 'no-comments', decision: 'NACK', reason: 'Found comments' },
+        ]);
+        const results = (0, commit_validator_js_1.parseBatchedOutput)(stdout, ['coverage-rules', 'no-comments']);
+        (0, vitest_1.expect)(results).toEqual([
+            { validator: 'coverage-rules', decision: 'ACK' },
+            { validator: 'no-comments', decision: 'NACK', reason: 'Found comments' },
+        ]);
+    });
+    (0, vitest_1.it)('extracts JSON array from markdown code fences', () => {
+        const inner = '```json\n[{"id":"v1","decision":"ACK"}]\n```';
+        const stdout = JSON.stringify({ type: 'result', subtype: 'success', result: inner });
+        const results = (0, commit_validator_js_1.parseBatchedOutput)(stdout, ['v1']);
+        (0, vitest_1.expect)(results).toEqual([{ validator: 'v1', decision: 'ACK' }]);
+    });
+    (0, vitest_1.it)('NACKs validators missing from response', () => {
+        const stdout = claudeBatchJson([{ id: 'v1', decision: 'ACK' }]);
+        const results = (0, commit_validator_js_1.parseBatchedOutput)(stdout, ['v1', 'v2']);
+        (0, vitest_1.expect)(results).toEqual([
+            { validator: 'v1', decision: 'ACK' },
+            { validator: 'v2', decision: 'NACK', reason: 'validator missing or invalid in batched response' },
+        ]);
+    });
+    (0, vitest_1.it)('NACKs all when response is unparseable', () => {
+        const stdout = JSON.stringify({ type: 'result', subtype: 'success', result: 'not json at all' });
+        const results = (0, commit_validator_js_1.parseBatchedOutput)(stdout, ['v1', 'v2']);
+        (0, vitest_1.expect)(results).toEqual([
+            { validator: 'v1', decision: 'NACK', reason: 'batched validator returned unparseable response' },
+            { validator: 'v2', decision: 'NACK', reason: 'batched validator returned unparseable response' },
+        ]);
+    });
+    (0, vitest_1.it)('accepts validator key as alias for id', () => {
+        const inner = [{ validator: 'v1', decision: 'ACK' }];
+        const stdout = JSON.stringify({ type: 'result', subtype: 'success', result: JSON.stringify(inner) });
+        const results = (0, commit_validator_js_1.parseBatchedOutput)(stdout, ['v1']);
+        (0, vitest_1.expect)(results).toEqual([{ validator: 'v1', decision: 'ACK' }]);
+    });
+});
+(0, vitest_1.describe)('runValidator', () => {
+    (0, vitest_1.it)('calls executor with formatted prompt', async () => {
+        const executor = vitest_1.vi.fn().mockReturnValue({
+            status: 0,
+            stdout: claudeJson({ decision: 'ACK' }),
+        });
+        const validator = {
+            name: 'test-validator',
+            description: 'Test',
+            enabled: true,
+            content: 'Check the commit',
+            path: '/validators/test.md',
+        };
+        const context = {
+            diff: '+hello world',
+            files: ['test.txt'],
+            message: 'Add test',
+        };
+        await (0, commit_validator_js_1.runValidator)(validator, context, executor);
+        (0, vitest_1.expect)(executor).toHaveBeenCalledWith('claude', ['-p', '--no-session-persistence', vitest_1.expect.stringContaining('<diff>'), '--output-format', 'json'], vitest_1.expect.objectContaining({ encoding: 'utf8' }));
+    });
+    (0, vitest_1.it)('includes validator content in prompt', async () => {
+        const executor = vitest_1.vi.fn().mockReturnValue({
+            status: 0,
+            stdout: claudeJson({ decision: 'ACK' }),
+        });
+        const validator = {
+            name: 'test-validator',
+            description: 'Test',
+            enabled: true,
+            content: 'Check that tests pass',
+            path: '/validators/test.md',
+        };
+        const context = {
+            diff: '+hello',
+            files: ['test.txt'],
+            message: 'Test commit',
+        };
+        await (0, commit_validator_js_1.runValidator)(validator, context, executor);
+        const prompt = executor.mock.calls[0][1][2];
+        (0, vitest_1.expect)(prompt).toContain('Check that tests pass');
+        (0, vitest_1.expect)(prompt).toContain('<diff>');
+        (0, vitest_1.expect)(prompt).toContain('+hello');
+        (0, vitest_1.expect)(prompt).toContain('<commit-message>');
+        (0, vitest_1.expect)(prompt).toContain('Test commit');
+        (0, vitest_1.expect)(prompt).toContain('<files>');
+        (0, vitest_1.expect)(prompt).toContain('test.txt');
+    });
+    (0, vitest_1.it)('parses ACK response from claude json wrapper', async () => {
+        const executor = vitest_1.vi.fn().mockReturnValue({
+            status: 0,
+            stdout: JSON.stringify({
+                type: 'result',
+                subtype: 'success',
+                result: '{"decision":"ACK"}',
+            }),
+        });
+        const validator = {
+            name: 'test',
+            description: 'Test',
+            enabled: true,
+            content: 'Check',
+            path: '/test.md',
+        };
+        const context = { diff: '+a', files: ['a.txt'], message: 'msg' };
+        const result = await (0, commit_validator_js_1.runValidator)(validator, context, executor);
+        (0, vitest_1.expect)(result).toEqual({ decision: 'ACK' });
+    });
+    (0, vitest_1.it)('parses NACK response with reason', async () => {
+        const executor = vitest_1.vi.fn().mockReturnValue({
+            status: 0,
+            stdout: claudeJson({ decision: 'NACK', reason: 'Missing tests' }),
+        });
+        const validator = {
+            name: 'test',
+            description: 'Test',
+            enabled: true,
+            content: 'Check',
+            path: '/test.md',
+        };
+        const context = { diff: '+a', files: ['a.txt'], message: 'msg' };
+        const result = await (0, commit_validator_js_1.runValidator)(validator, context, executor);
+        (0, vitest_1.expect)(result).toEqual({ decision: 'NACK', reason: 'Missing tests' });
+    });
+    (0, vitest_1.it)('retries once when response is invalid then succeeds', async () => {
+        const executor = vitest_1.vi
+            .fn()
+            .mockReturnValueOnce({
+            status: 0,
+            stdout: claudeJson({ some: 'garbage' }),
+        })
+            .mockReturnValueOnce({
+            status: 0,
+            stdout: claudeJson({ decision: 'ACK' }),
+        });
+        const validator = {
+            name: 'test',
+            description: 'Test',
+            enabled: true,
+            content: 'Check',
+            path: '/test.md',
+        };
+        const context = { diff: '+a', files: ['a.txt'], message: 'msg' };
+        const result = await (0, commit_validator_js_1.runValidator)(validator, context, executor);
+        (0, vitest_1.expect)(result).toEqual({ decision: 'ACK' });
+        (0, vitest_1.expect)(executor).toHaveBeenCalledTimes(2);
+    });
+    (0, vitest_1.it)('returns NACK after retry also fails', async () => {
+        const executor = vitest_1.vi.fn().mockReturnValue({
+            status: 0,
+            stdout: claudeJson({ some: 'garbage' }),
+        });
+        const validator = {
+            name: 'test',
+            description: 'Test',
+            enabled: true,
+            content: 'Check',
+            path: '/test.md',
+        };
+        const context = { diff: '+a', files: ['a.txt'], message: 'msg' };
+        const result = await (0, commit_validator_js_1.runValidator)(validator, context, executor);
+        (0, vitest_1.expect)(result).toEqual({ decision: 'NACK', reason: 'validator returned invalid response (no ACK decision)' });
+        (0, vitest_1.expect)(executor).toHaveBeenCalledTimes(2);
+    });
+});
+(0, vitest_1.describe)('runAppealValidator', () => {
+    (0, vitest_1.it)('includes validator results and appeal in prompt', async () => {
+        const executor = vitest_1.vi.fn().mockReturnValue({
+            status: 0,
+            stdout: claudeJson({ decision: 'ACK' }),
+        });
+        const appealValidator = {
+            name: 'appeal-system',
+            description: 'Evaluate appeals',
+            enabled: true,
+            content: 'Judge the appeal',
+            path: '/appeal.md',
+        };
+        const context = {
+            diff: '+hello',
+            files: ['test.txt'],
+            message: 'feat: add feature [appeal: coherence]',
+        };
+        const results = [
+            { validator: 'coverage-rules', decision: 'NACK', reason: 'Missing tests', appealable: true },
+        ];
+        const appeal = 'these files are tightly coupled';
+        await (0, commit_validator_js_1.runAppealValidator)(appealValidator, context, results, appeal, executor);
+        const prompt = executor.mock.calls[0][1][2];
+        (0, vitest_1.expect)(prompt).toContain('<validator-results>');
+        (0, vitest_1.expect)(prompt).toContain('coverage-rules: NACK - Missing tests');
+        (0, vitest_1.expect)(prompt).toContain('<appeal>');
+        (0, vitest_1.expect)(prompt).toContain('these files are tightly coupled');
+        (0, vitest_1.expect)(prompt).toContain('Judge the appeal');
+    });
+    (0, vitest_1.it)('returns ACK when appeal is valid', async () => {
+        const executor = vitest_1.vi.fn().mockReturnValue({
+            status: 0,
+            stdout: claudeJson({ decision: 'ACK' }),
+        });
+        const appealValidator = {
+            name: 'appeal-system',
+            description: 'Evaluate appeals',
+            enabled: true,
+            content: 'Judge',
+            path: '/appeal.md',
+        };
+        const context = { diff: '+a', files: ['a.txt'], message: 'msg' };
+        const results = [{ validator: 'v1', decision: 'NACK', reason: 'reason', appealable: true }];
+        const result = await (0, commit_validator_js_1.runAppealValidator)(appealValidator, context, results, 'coherence', executor);
+        (0, vitest_1.expect)(result).toEqual({ decision: 'ACK' });
+    });
+    (0, vitest_1.it)('returns NACK when appeal is invalid', async () => {
+        const executor = vitest_1.vi.fn().mockReturnValue({
+            status: 0,
+            stdout: claudeJson({ decision: 'NACK', reason: 'Appeal does not justify violation' }),
+        });
+        const appealValidator = {
+            name: 'appeal-system',
+            description: 'Evaluate appeals',
+            enabled: true,
+            content: 'Judge',
+            path: '/appeal.md',
+        };
+        const context = { diff: '+a', files: ['a.txt'], message: 'msg' };
+        const results = [{ validator: 'v1', decision: 'NACK', reason: 'reason', appealable: true }];
+        const result = await (0, commit_validator_js_1.runAppealValidator)(appealValidator, context, results, 'please let me in', executor);
+        (0, vitest_1.expect)(result).toEqual({ decision: 'NACK', reason: 'Appeal does not justify violation' });
+    });
+});
+(0, vitest_1.describe)('validateCommit', () => {
+    (0, vitest_1.it)('builds batched prompt with validator tags and stripped boilerplate', async () => {
+        const executor = vitest_1.vi.fn().mockReturnValue({
+            status: 0,
+            stdout: claudeBatchJson([{ id: 'v1', decision: 'ACK' }]),
+        });
+        const boilerplateContent = `You are a commit validator. You MUST respond with ONLY a JSON object, no other text.
+
+Valid responses:
+{"decision":"ACK"}
+{"decision":"NACK","reason":"one sentence explanation"}
+
+Check for tests.
+
+RESPOND WITH JSON ONLY - NO PROSE, NO MARKDOWN, NO EXPLANATION OUTSIDE THE JSON.`;
+        const validators = [
+            { name: 'v1', description: 'd1', enabled: true, content: boilerplateContent, path: '/v1.md' },
+        ];
+        const context = { diff: '+a', files: ['a.txt'], message: 'msg' };
+        await (0, commit_validator_js_1.validateCommit)(validators, context, executor);
+        const prompt = executor.mock.calls[0][1][2];
+        (0, vitest_1.expect)(prompt).toContain('<validator id="v1">');
+        (0, vitest_1.expect)(prompt).toContain('Check for tests.');
+        (0, vitest_1.expect)(prompt).not.toContain('You are a commit validator. You MUST');
+        (0, vitest_1.expect)(prompt).not.toContain('RESPOND WITH JSON ONLY');
+        (0, vitest_1.expect)(prompt).not.toContain('Valid responses:');
+        (0, vitest_1.expect)(prompt).toContain('Respond with ONLY a JSON array');
+    });
+    (0, vitest_1.it)('runs batches in parallel and returns flattened results', async () => {
+        const callLog = [];
+        const asyncExecutor = vitest_1.vi.fn().mockImplementation((_cmd, args) => {
+            const prompt = args[2];
+            const batchName = prompt.includes('"v1"') ? 'batch-0' : prompt.includes('"v2"') ? 'batch-1' : 'batch-2';
+            callLog.push(`start:${batchName}`);
+            return new Promise((resolve) => {
+                setTimeout(() => {
+                    callLog.push(`end:${batchName}`);
+                    const id = batchName === 'batch-0' ? 'v1' : batchName === 'batch-1' ? 'v2' : 'v3';
+                    resolve({ status: 0, stdout: claudeBatchJson([{ id, decision: 'ACK' }]) });
+                }, 50);
+            });
+        });
+        const validators = [
+            { name: 'v1', description: 'd1', enabled: true, content: 'c1', path: '/v1.md' },
+            { name: 'v2', description: 'd2', enabled: true, content: 'c2', path: '/v2.md' },
+            { name: 'v3', description: 'd3', enabled: true, content: 'c3', path: '/v3.md' },
+        ];
+        const context = { diff: '+a', files: ['a.txt'], message: 'msg' };
+        const results = await (0, commit_validator_js_1.validateCommit)(validators, context, asyncExecutor);
+        (0, vitest_1.expect)(results).toEqual([
+            { validator: 'v1', decision: 'ACK', appealable: true },
+            { validator: 'v2', decision: 'ACK', appealable: true },
+            { validator: 'v3', decision: 'ACK', appealable: true },
+        ]);
+        (0, vitest_1.expect)(asyncExecutor).toHaveBeenCalledTimes(3);
+        (0, vitest_1.expect)(callLog).toEqual([
+            'start:batch-0',
+            'start:batch-1',
+            'start:batch-2',
+            'end:batch-0',
+            'end:batch-1',
+            'end:batch-2',
+        ]);
+    });
+    (0, vitest_1.it)('aggregates NACK reasons from batched responses', async () => {
+        const executor = vitest_1.vi
+            .fn()
+            .mockReturnValueOnce({ status: 0, stdout: claudeBatchJson([{ id: 'v1', decision: 'ACK' }]) })
+            .mockReturnValueOnce({
+            status: 0,
+            stdout: claudeBatchJson([{ id: 'v2', decision: 'NACK', reason: 'Missing tests' }]),
+        })
+            .mockReturnValueOnce({
+            status: 0,
+            stdout: claudeBatchJson([{ id: 'v3', decision: 'NACK', reason: 'No coverage' }]),
+        });
+        const validators = [
+            { name: 'v1', description: 'd1', enabled: true, content: 'c1', path: '/v1.md' },
+            { name: 'v2', description: 'd2', enabled: true, content: 'c2', path: '/v2.md' },
+            { name: 'v3', description: 'd3', enabled: true, content: 'c3', path: '/v3.md' },
+        ];
+        const context = { diff: '+a', files: ['a.txt'], message: 'msg' };
+        const results = await (0, commit_validator_js_1.validateCommit)(validators, context, executor);
+        (0, vitest_1.expect)(results).toEqual([
+            { validator: 'v1', decision: 'ACK', appealable: true },
+            { validator: 'v2', decision: 'NACK', reason: 'Missing tests', appealable: true },
+            { validator: 'v3', decision: 'NACK', reason: 'No coverage', appealable: true },
+        ]);
+    });
+    (0, vitest_1.it)('marks no-dangerous-git as not appealable', async () => {
+        const executor = vitest_1.vi.fn().mockReturnValue({
+            status: 0,
+            stdout: claudeBatchJson([{ id: 'no-dangerous-git', decision: 'NACK', reason: '--force is forbidden' }]),
+        });
+        const validators = [
+            { name: 'no-dangerous-git', description: 'd', enabled: true, content: 'c', path: '/v.md' },
+        ];
+        const context = { diff: '+a', files: ['a.txt'], message: 'msg' };
+        const results = await (0, commit_validator_js_1.validateCommit)(validators, context, executor);
+        (0, vitest_1.expect)(results).toEqual([
+            { validator: 'no-dangerous-git', decision: 'NACK', reason: '--force is forbidden', appealable: false },
+        ]);
+    });
+    (0, vitest_1.it)('NACKs all validators in a batch when executor throws', async () => {
+        const executor = vitest_1.vi.fn().mockRejectedValue(new Error('connection refused'));
+        const validators = [{ name: 'v1', description: 'd', enabled: true, content: 'c', path: '/v.md' }];
+        const context = { diff: '+a', files: ['a.txt'], message: 'msg' };
+        const results = await (0, commit_validator_js_1.validateCommit)(validators, context, executor);
+        (0, vitest_1.expect)(results).toEqual([
+            { validator: 'v1', decision: 'NACK', reason: 'validator crashed: Error: connection refused', appealable: false },
+        ]);
+    });
+    (0, vitest_1.it)('logs shared token counts for all validators in a batch', async () => {
+        const stdout = JSON.stringify({
+            type: 'result',
+            subtype: 'success',
+            result: JSON.stringify([{ id: 'v1', decision: 'ACK' }]),
+            usage: { input_tokens: 100, output_tokens: 20, cache_read_input_tokens: 50 },
+        });
+        const executor = vitest_1.vi.fn().mockReturnValue({ status: 0, stdout });
+        const logs = [];
+        const onLog = (event, name, detail) => {
+            logs.push({ event, name, detail });
+        };
+        const validators = [{ name: 'v1', description: 'd', enabled: true, content: 'c', path: '/v.md' }];
+        const context = { diff: '+a', files: ['a.txt'], message: 'msg' };
+        await (0, commit_validator_js_1.validateCommit)(validators, context, executor, onLog);
+        (0, vitest_1.expect)(logs).toEqual([
+            { event: 'spawn', name: 'batch-0', detail: 'validators: v1' },
+            { event: 'complete', name: 'v1', detail: 'ACK (in:150 out:20)' },
+        ]);
+    });
+    (0, vitest_1.it)('uses provided batchCount to control chunk size', async () => {
+        const executor = vitest_1.vi.fn().mockImplementation((_cmd, args) => {
+            const prompt = args[2];
+            if (prompt.includes('"v1"') && prompt.includes('"v2"')) {
+                return {
+                    status: 0,
+                    stdout: claudeBatchJson([
+                        { id: 'v1', decision: 'ACK' },
+                        { id: 'v2', decision: 'ACK' },
+                    ]),
+                };
+            }
+            return {
+                status: 0,
+                stdout: claudeBatchJson([
+                    { id: 'v3', decision: 'ACK' },
+                    { id: 'v4', decision: 'ACK' },
+                ]),
+            };
+        });
+        const validators = [
+            { name: 'v1', description: 'd', enabled: true, content: 'c1', path: '/v1.md' },
+            { name: 'v2', description: 'd', enabled: true, content: 'c2', path: '/v2.md' },
+            { name: 'v3', description: 'd', enabled: true, content: 'c3', path: '/v3.md' },
+            { name: 'v4', description: 'd', enabled: true, content: 'c4', path: '/v4.md' },
+        ];
+        const context = { diff: '+a', files: ['a.txt'], message: 'msg' };
+        const results = await (0, commit_validator_js_1.validateCommit)(validators, context, executor, undefined, 2);
+        (0, vitest_1.expect)(results).toEqual([
+            { validator: 'v1', decision: 'ACK', appealable: true },
+            { validator: 'v2', decision: 'ACK', appealable: true },
+            { validator: 'v3', decision: 'ACK', appealable: true },
+            { validator: 'v4', decision: 'ACK', appealable: true },
+        ]);
+        (0, vitest_1.expect)(executor).toHaveBeenCalledTimes(2);
+    });
+});
+(0, vitest_1.describe)('handleCommitValidation', () => {
+    (0, vitest_1.it)('allows commit when all validators ACK', async () => {
+        const executor = vitest_1.vi.fn().mockReturnValue({
+            status: 0,
+            stdout: claudeBatchJson([{ id: 'v1', decision: 'ACK' }]),
+        });
+        const validators = [{ name: 'v1', description: 'd', enabled: true, content: 'c', path: '/v.md' }];
+        const context = { diff: '+a', files: ['a.txt'], message: 'feat: add feature' };
+        const result = await (0, commit_validator_js_1.handleCommitValidation)(validators, context, executor);
+        (0, vitest_1.expect)(result).toEqual({ allowed: true, results: vitest_1.expect.any(Array) });
+    });
+    (0, vitest_1.it)('blocks commit when validator NACKs without appeal', async () => {
+        const executor = vitest_1.vi.fn().mockReturnValue({
+            status: 0,
+            stdout: claudeBatchJson([{ id: 'coverage-rules', decision: 'NACK', reason: 'Missing tests' }]),
+        });
+        const validators = [
+            { name: 'coverage-rules', description: 'd', enabled: true, content: 'c', path: '/v.md' },
+        ];
+        const context = { diff: '+a', files: ['a.txt'], message: 'feat: add feature' };
+        const result = await (0, commit_validator_js_1.handleCommitValidation)(validators, context, executor);
+        (0, vitest_1.expect)(result).toEqual({
+            allowed: false,
+            results: vitest_1.expect.any(Array),
+            blockedBy: ['coverage-rules'],
+        });
+    });
+    (0, vitest_1.it)('allows commit when appeal validator ACKs the appeal', async () => {
+        const executor = vitest_1.vi
+            .fn()
+            .mockReturnValueOnce({
+            status: 0,
+            stdout: claudeBatchJson([{ id: 'coverage-rules', decision: 'NACK', reason: 'Missing tests' }]),
+        })
+            .mockReturnValueOnce({
+            status: 0,
+            stdout: claudeJson({ decision: 'ACK' }),
+        });
+        const validators = [
+            { name: 'coverage-rules', description: 'd', enabled: true, content: 'c', path: '/v.md' },
+        ];
+        const appealValidator = {
+            name: 'appeal-system',
+            description: 'Appeal validator',
+            enabled: true,
+            content: 'Evaluate appeal',
+            path: '/appeal.md',
+        };
+        const context = {
+            diff: '+a',
+            files: ['a.txt'],
+            message: 'feat: add feature [appeal: these files are tightly coupled]',
+        };
+        const result = await (0, commit_validator_js_1.handleCommitValidation)(validators, context, executor, appealValidator);
+        (0, vitest_1.expect)(result).toEqual({
+            allowed: true,
+            results: vitest_1.expect.any(Array),
+            appeal: 'these files are tightly coupled',
+        });
+    });
+    (0, vitest_1.it)('blocks commit when appeal validator NACKs the appeal', async () => {
+        const executor = vitest_1.vi
+            .fn()
+            .mockReturnValueOnce({
+            status: 0,
+            stdout: claudeBatchJson([{ id: 'coverage-rules', decision: 'NACK', reason: 'Missing tests' }]),
+        })
+            .mockReturnValueOnce({
+            status: 0,
+            stdout: claudeJson({ decision: 'NACK', reason: 'Appeal does not justify violation' }),
+        });
+        const validators = [
+            { name: 'coverage-rules', description: 'd', enabled: true, content: 'c', path: '/v.md' },
+        ];
+        const appealValidator = {
+            name: 'appeal-system',
+            description: 'Appeal validator',
+            enabled: true,
+            content: 'Evaluate appeal',
+            path: '/appeal.md',
+        };
+        const context = {
+            diff: '+a',
+            files: ['a.txt'],
+            message: 'feat: add feature [appeal: please let this through]',
+        };
+        const result = await (0, commit_validator_js_1.handleCommitValidation)(validators, context, executor, appealValidator);
+        (0, vitest_1.expect)(result).toEqual({
+            allowed: false,
+            results: vitest_1.expect.any(Array),
+            blockedBy: ['coverage-rules'],
+        });
+    });
+    (0, vitest_1.it)('blocks commit when no appeal validator provided and NACK with appeal', async () => {
+        const executor = vitest_1.vi.fn().mockReturnValue({
+            status: 0,
+            stdout: claudeBatchJson([{ id: 'coverage-rules', decision: 'NACK', reason: 'Missing tests' }]),
+        });
+        const validators = [
+            { name: 'coverage-rules', description: 'd', enabled: true, content: 'c', path: '/v.md' },
+        ];
+        const context = {
+            diff: '+a',
+            files: ['a.txt'],
+            message: 'feat: add feature [appeal: coherence]',
+        };
+        const result = await (0, commit_validator_js_1.handleCommitValidation)(validators, context, executor);
+        (0, vitest_1.expect)(result).toEqual({
+            allowed: false,
+            results: vitest_1.expect.any(Array),
+            blockedBy: ['coverage-rules'],
+        });
+    });
+});
+(0, vitest_1.describe)('formatBlockMessage', () => {
+    (0, vitest_1.it)('formats block message with validator reasons and appeal instructions', () => {
+        const results = [
+            { validator: 'coverage-rules', decision: 'NACK', reason: 'Missing tests', appealable: true },
+        ];
+        const message = (0, commit_validator_js_1.formatBlockMessage)(results);
+        (0, vitest_1.expect)(message).toContain('coverage-rules: Missing tests');
+        (0, vitest_1.expect)(message).toContain('[appeal: your justification]');
+    });
+    (0, vitest_1.it)('omits appeal instructions for non-appealable validators', () => {
+        const results = [
+            { validator: 'no-dangerous-git', decision: 'NACK', reason: '--force forbidden', appealable: false },
+        ];
+        const message = (0, commit_validator_js_1.formatBlockMessage)(results);
+        (0, vitest_1.expect)(message).toContain('no-dangerous-git: --force forbidden');
+        (0, vitest_1.expect)(message).toContain('cannot be appealed');
+    });
+});
+//# sourceMappingURL=commit-validator.test.js.map