@fcamblor/on-changes-run 0.0.1 → 0.0.2

package/dist/__tests__/executor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/executor.test.js

@@ -0,0 +1,183 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+vi.mock('node:child_process', () => ({
+    exec: vi.fn(),
+}));
+import { exec } from 'node:child_process';
+import { executeCommand, executeAll, printFailures } from '../executor.js';
+const mockExec = vi.mocked(exec);
+// promisify resolves with { stdout, stderr } only if the original function has
+// util.promisify.custom — which the real exec does but vi.fn() does not.
+// Passing a single object as the callback value makes promisify resolve with it directly.
+function stubExecSuccess(stdout, stderr = '') {
+    return mockExec.mockImplementationOnce((_cmd, _opts, callback) => {
+        callback(null, { stdout, stderr });
+        return undefined;
+    });
+}
+function stubExecFailure(exitCode, stdout = '', stderr = '') {
+    return mockExec.mockImplementationOnce((_cmd, _opts, callback) => {
+        const err = Object.assign(new Error('Command failed'), { code: exitCode, stdout, stderr });
+        callback(err, { stdout, stderr });
+        return undefined;
+    });
+}
+beforeEach(() => {
+    mockExec.mockReset();
+});
+// ---------------------------------------------------------------------------
+// executeCommand
+// ---------------------------------------------------------------------------
+describe('executeCommand', () => {
+    it('returns exitCode 0 and captured output on success', async () => {
+        stubExecSuccess('hello stdout', 'some stderr');
+        const result = await executeCommand('echo hello', 5000);
+        expect(result).toEqual({
+            command: 'echo hello',
+            exitCode: 0,
+            stdout: 'hello stdout',
+            stderr: 'some stderr',
+        });
+    });
+    it('returns non-zero exitCode and output on failure', async () => {
+        stubExecFailure(1, 'fail stdout', 'fail stderr');
+        const result = await executeCommand('false', 5000);
+        expect(result).toEqual({
+            command: 'false',
+            exitCode: 1,
+            stdout: 'fail stdout',
+            stderr: 'fail stderr',
+        });
+    });
+    it('uses the provided exit code from the error', async () => {
+        stubExecFailure(42, '', 'error message');
+        const result = await executeCommand('exit 42', 5000);
+        expect(result.exitCode).toBe(42);
+    });
+    it('defaults exitCode to 1 when error has no code', async () => {
+        mockExec.mockImplementationOnce((_cmd, _opts, callback) => {
+            callback(new Error('no code'), '', '');
+            return undefined;
+        });
+        const result = await executeCommand('bad', 5000);
+        expect(result.exitCode).toBe(1);
+    });
+    it('returns empty strings for stdout/stderr when missing from error', async () => {
+        mockExec.mockImplementationOnce((_cmd, _opts, callback) => {
+            const err = Object.assign(new Error('fail'), { code: 1 });
+            callback(err, undefined, undefined);
+            return undefined;
+        });
+        const result = await executeCommand('bad', 5000);
+        expect(result.stdout).toBe('');
+        expect(result.stderr).toBe('');
+    });
+    it('passes the command string through to the result', async () => {
+        stubExecSuccess('');
+        const result = await executeCommand('cd frontend && npm run lint', 5000);
+        expect(result.command).toBe('cd frontend && npm run lint');
+    });
+    it('passes env vars to the child process', async () => {
+        stubExecSuccess('');
+        const env = { MY_VAR: 'my_value' };
+        await executeCommand('echo $MY_VAR', 5000, env);
+        expect(mockExec).toHaveBeenCalledWith('echo $MY_VAR', expect.objectContaining({ env: expect.objectContaining({ MY_VAR: 'my_value' }) }), expect.any(Function));
+    });
+    it('merges env vars with process.env', async () => {
+        stubExecSuccess('');
+        await executeCommand('cmd', 5000, { CUSTOM: 'value' });
+        const callOpts = vi.mocked(mockExec).mock.calls[0][1];
+        expect(callOpts.env).toMatchObject({ CUSTOM: 'value', ...process.env });
+    });
+    it('passes timeout to exec options', async () => {
+        stubExecSuccess('');
+        await executeCommand('cmd', 12345);
+        const callOpts = vi.mocked(mockExec).mock.calls[0][1];
+        expect(callOpts.timeout).toBe(12345);
+    });
+});
+// ---------------------------------------------------------------------------
+// executeAll
+// ---------------------------------------------------------------------------
+describe('executeAll', () => {
+    it('returns results for all commands', async () => {
+        stubExecSuccess('out1');
+        stubExecSuccess('out2');
+        const results = await executeAll(['cmd1', 'cmd2'], 5000);
+        expect(results).toHaveLength(2);
+        expect(results[0].command).toBe('cmd1');
+        expect(results[1].command).toBe('cmd2');
+    });
+    it('returns results for both successes and failures', async () => {
+        stubExecSuccess('ok');
+        stubExecFailure(1, '', 'err');
+        const results = await executeAll(['ok-cmd', 'fail-cmd'], 5000);
+        expect(results[0].exitCode).toBe(0);
+        expect(results[1].exitCode).toBe(1);
+    });
+    it('returns empty array for empty command list', async () => {
+        expect(await executeAll([], 5000)).toEqual([]);
+    });
+    it('passes env vars to all commands', async () => {
+        stubExecSuccess('');
+        stubExecSuccess('');
+        const env = { FOO: 'bar' };
+        await executeAll(['cmd1', 'cmd2'], 5000, env);
+        for (const call of mockExec.mock.calls) {
+            expect(call[1].env).toMatchObject({ FOO: 'bar' });
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// printFailures
+// ---------------------------------------------------------------------------
+describe('printFailures', () => {
+    it('writes failure header with command and exit code', () => {
+        const spy = vi.spyOn(process.stderr, 'write').mockReturnValue(true);
+        printFailures([{ command: 'npm run lint', exitCode: 1, stdout: '', stderr: '' }]);
+        const output = spy.mock.calls.map((c) => c[0]).join('');
+        expect(output).toContain('FAILED: npm run lint');
+        expect(output).toContain('exit code 1');
+        spy.mockRestore();
+    });
+    it('includes stdout when present', () => {
+        const spy = vi.spyOn(process.stderr, 'write').mockReturnValue(true);
+        printFailures([{ command: 'cmd', exitCode: 1, stdout: 'some output', stderr: '' }]);
+        const output = spy.mock.calls.map((c) => c[0]).join('');
+        expect(output).toContain('[stdout]');
+        expect(output).toContain('some output');
+        spy.mockRestore();
+    });
+    it('includes stderr when present', () => {
+        const spy = vi.spyOn(process.stderr, 'write').mockReturnValue(true);
+        printFailures([{ command: 'cmd', exitCode: 2, stdout: '', stderr: 'error details' }]);
+        const output = spy.mock.calls.map((c) => c[0]).join('');
+        expect(output).toContain('[stderr]');
+        expect(output).toContain('error details');
+        spy.mockRestore();
+    });
+    it('omits [stdout] block when stdout is empty', () => {
+        const spy = vi.spyOn(process.stderr, 'write').mockReturnValue(true);
+        printFailures([{ command: 'cmd', exitCode: 1, stdout: '', stderr: 'err' }]);
+        const output = spy.mock.calls.map((c) => c[0]).join('');
+        expect(output).not.toContain('[stdout]');
+        spy.mockRestore();
+    });
+    it('omits [stderr] block when stderr is empty', () => {
+        const spy = vi.spyOn(process.stderr, 'write').mockReturnValue(true);
+        printFailures([{ command: 'cmd', exitCode: 1, stdout: 'out', stderr: '' }]);
+        const output = spy.mock.calls.map((c) => c[0]).join('');
+        expect(output).not.toContain('[stderr]');
+        spy.mockRestore();
+    });
+    it('prints a section for each failed command', () => {
+        const spy = vi.spyOn(process.stderr, 'write').mockReturnValue(true);
+        printFailures([
+            { command: 'cmd1', exitCode: 1, stdout: '', stderr: 'err1' },
+            { command: 'cmd2', exitCode: 2, stdout: '', stderr: 'err2' },
+        ]);
+        const output = spy.mock.calls.map((c) => c[0]).join('');
+        expect(output).toContain('FAILED: cmd1');
+        expect(output).toContain('FAILED: cmd2');
+        spy.mockRestore();
+    });
+});

package/dist/__tests__/git.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/git.test.js

@@ -0,0 +1,93 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+vi.mock('node:child_process', () => ({
+    execFile: vi.fn(),
+}));
+import { execFile } from 'node:child_process';
+import { getGitRoot, getHeadSha, getDiffFiles } from '../git.js';
+const mockExecFile = vi.mocked(execFile);
+// promisify resolves with { stdout, stderr } only if the original function has
+// util.promisify.custom — which the real execFile does but vi.fn() does not.
+// Passing a single object as the callback value makes promisify resolve with it directly.
+function stubExecFile(stdout, stderr = '') {
+    return mockExecFile.mockImplementationOnce((_cmd, _args, callback) => {
+        callback(null, { stdout, stderr });
+        return undefined;
+    });
+}
+function stubExecFileError(error) {
+    return mockExecFile.mockImplementationOnce((_cmd, _args, callback) => {
+        callback(error, { stdout: '', stderr: '' });
+        return undefined;
+    });
+}
+beforeEach(() => {
+    mockExecFile.mockReset();
+});
+describe('getGitRoot', () => {
+    it('returns trimmed git root path', async () => {
+        stubExecFile('/home/user/project\n');
+        expect(await getGitRoot()).toBe('/home/user/project');
+    });
+    it('calls git rev-parse --show-toplevel', async () => {
+        stubExecFile('/some/path\n');
+        await getGitRoot();
+        expect(mockExecFile).toHaveBeenCalledWith('git', ['rev-parse', '--show-toplevel'], expect.any(Function));
+    });
+    it('throws when git command fails', async () => {
+        stubExecFileError(new Error('not a git repository'));
+        await expect(getGitRoot()).rejects.toThrow('not a git repository');
+    });
+});
+describe('getHeadSha', () => {
+    it('returns trimmed HEAD SHA', async () => {
+        stubExecFile('a4872f4584ce55be198c06cc1c33c2894b47dbe3\n');
+        expect(await getHeadSha()).toBe('a4872f4584ce55be198c06cc1c33c2894b47dbe3');
+    });
+    it('calls git rev-parse HEAD', async () => {
+        stubExecFile('abc123\n');
+        await getHeadSha();
+        expect(mockExecFile).toHaveBeenCalledWith('git', ['rev-parse', 'HEAD'], expect.any(Function));
+    });
+    it('throws when git command fails', async () => {
+        stubExecFileError(new Error('no HEAD'));
+        await expect(getHeadSha()).rejects.toThrow('no HEAD');
+    });
+});
+describe('getDiffFiles', () => {
+    it('returns empty array when no files are in diff', async () => {
+        stubExecFile(''); // unstaged
+        stubExecFile(''); // staged
+        expect(await getDiffFiles()).toEqual([]);
+    });
+    it('returns unstaged files only', async () => {
+        stubExecFile('src/a.ts\nsrc/b.ts\n'); // unstaged
+        stubExecFile(''); // staged
+        expect(await getDiffFiles()).toEqual(['src/a.ts', 'src/b.ts']);
+    });
+    it('returns staged files only', async () => {
+        stubExecFile(''); // unstaged
+        stubExecFile('src/c.ts\nsrc/d.ts\n'); // staged
+        expect(await getDiffFiles()).toEqual(['src/c.ts', 'src/d.ts']);
+    });
+    it('returns deduplicated union of unstaged and staged files', async () => {
+        stubExecFile('src/a.ts\nsrc/b.ts\n'); // unstaged
+        stubExecFile('src/b.ts\nsrc/c.ts\n'); // staged — b.ts appears in both
+        const result = await getDiffFiles();
+        expect(result).toHaveLength(3);
+        expect(result).toContain('src/a.ts');
+        expect(result).toContain('src/b.ts');
+        expect(result).toContain('src/c.ts');
+    });
+    it('silently returns empty array when git fails', async () => {
+        mockExecFile.mockImplementation((_cmd, _args, callback) => {
+            callback(new Error('git not found'), '', '');
+            return undefined;
+        });
+        expect(await getDiffFiles()).toEqual([]);
+    });
+    it('ignores empty lines in git output', async () => {
+        stubExecFile('\nsrc/a.ts\n\n'); // unstaged with empty lines
+        stubExecFile(''); // staged
+        expect(await getDiffFiles()).toEqual(['src/a.ts']);
+    });
+});

package/dist/__tests__/state.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/state.test.js

@@ -0,0 +1,190 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import { createHash } from 'node:crypto';
+import { join } from 'node:path';
+vi.mock('node:fs/promises', () => ({
+    readFile: vi.fn(),
+    writeFile: vi.fn(),
+    mkdir: vi.fn(),
+}));
+vi.mock('node:fs', () => ({
+    readFileSync: vi.fn(),
+}));
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { readFileSync } from 'node:fs';
+import { computeFileHash, computeHashes, loadState, saveState, findChangedFiles, } from '../state.js';
+const mockReadFile = vi.mocked(readFile);
+const mockWriteFile = vi.mocked(writeFile);
+const mockMkdir = vi.mocked(mkdir);
+const mockReadFileSync = vi.mocked(readFileSync);
+beforeEach(() => {
+    vi.clearAllMocks();
+    mockWriteFile.mockResolvedValue(undefined);
+    mockMkdir.mockResolvedValue(undefined);
+});
+// ---------------------------------------------------------------------------
+// findChangedFiles — pure function, no mocks needed
+// ---------------------------------------------------------------------------
+describe('findChangedFiles', () => {
+    it('returns empty array when both snapshots are identical', () => {
+        const hashes = { 'src/a.ts': 'hash1', 'src/b.ts': 'hash2' };
+        expect(findChangedFiles(hashes, { ...hashes })).toEqual([]);
+    });
+    it('detects a file with a different hash', () => {
+        const previous = { 'src/a.ts': 'hash1' };
+        const current = { 'src/a.ts': 'hash2' };
+        expect(findChangedFiles(previous, current)).toEqual(['src/a.ts']);
+    });
+    it('detects a newly modified file (not in previous snapshot)', () => {
+        const previous = { 'src/a.ts': 'hash1' };
+        const current = { 'src/a.ts': 'hash1', 'src/b.ts': 'hash2' };
+        expect(findChangedFiles(previous, current)).toEqual(['src/b.ts']);
+    });
+    it('detects a file that was cleaned/committed since last run (not in current snapshot)', () => {
+        const previous = { 'src/a.ts': 'hash1', 'src/b.ts': 'hash2' };
+        const current = { 'src/a.ts': 'hash1' };
+        expect(findChangedFiles(previous, current)).toEqual(['src/b.ts']);
+    });
+    it('handles multiple changes at once', () => {
+        const previous = { 'src/a.ts': 'hash1', 'src/b.ts': 'hash2', 'src/c.ts': 'hash3' };
+        const current = { 'src/a.ts': 'hash1-new', 'src/d.ts': 'hash4' };
+        const changed = findChangedFiles(previous, current);
+        expect(changed).toContain('src/a.ts'); // modified
+        expect(changed).toContain('src/b.ts'); // deleted
+        expect(changed).toContain('src/c.ts'); // deleted
+        expect(changed).toContain('src/d.ts'); // new
+        expect(changed).toHaveLength(4);
+    });
+    it('returns empty array when both snapshots are empty', () => {
+        expect(findChangedFiles({}, {})).toEqual([]);
+    });
+});
+// ---------------------------------------------------------------------------
+// computeFileHash
+// ---------------------------------------------------------------------------
+describe('computeFileHash', () => {
+    it('returns sha256 hex hash of file content', async () => {
+        const content = Buffer.from('hello world');
+        mockReadFile.mockResolvedValue(content);
+        const expected = createHash('sha256').update(content).digest('hex');
+        expect(await computeFileHash('/some/file.ts')).toBe(expected);
+        expect(mockReadFile).toHaveBeenCalledWith('/some/file.ts');
+    });
+    it('produces different hashes for different content', async () => {
+        mockReadFile.mockResolvedValueOnce(Buffer.from('content A'));
+        const hash1 = await computeFileHash('/a.ts');
+        mockReadFile.mockResolvedValueOnce(Buffer.from('content B'));
+        const hash2 = await computeFileHash('/b.ts');
+        expect(hash1).not.toBe(hash2);
+    });
+    it('produces the same hash for identical content', async () => {
+        const content = Buffer.from('same content');
+        mockReadFile.mockResolvedValue(content);
+        const hash1 = await computeFileHash('/a.ts');
+        const hash2 = await computeFileHash('/b.ts');
+        expect(hash1).toBe(hash2);
+    });
+    it('throws when file cannot be read', async () => {
+        mockReadFile.mockRejectedValue(new Error('ENOENT: no such file'));
+        await expect(computeFileHash('/missing.ts')).rejects.toThrow('ENOENT');
+    });
+});
+// ---------------------------------------------------------------------------
+// computeHashes
+// ---------------------------------------------------------------------------
+describe('computeHashes', () => {
+    it('returns empty record for empty file list', async () => {
+        expect(await computeHashes('/git/root', [])).toEqual({});
+    });
+    it('returns hashes keyed by relative paths', async () => {
+        const contentA = Buffer.from('content A');
+        const contentB = Buffer.from('content B');
+        mockReadFile.mockResolvedValueOnce(contentA);
+        mockReadFile.mockResolvedValueOnce(contentB);
+        const result = await computeHashes('/root', ['src/a.ts', 'src/b.ts']);
+        expect(result).toHaveProperty('src/a.ts');
+        expect(result).toHaveProperty('src/b.ts');
+        expect(result['src/a.ts']).toBe(createHash('sha256').update(contentA).digest('hex'));
+        expect(result['src/b.ts']).toBe(createHash('sha256').update(contentB).digest('hex'));
+    });
+    it('reads files using absolute paths (gitRoot + relative)', async () => {
+        mockReadFile.mockResolvedValue(Buffer.from('x'));
+        await computeHashes('/my/project', ['src/file.ts']);
+        expect(mockReadFile).toHaveBeenCalledWith(join('/my/project', 'src/file.ts'));
+    });
+    it('skips files that cannot be read (e.g. deleted since diff was run)', async () => {
+        mockReadFile.mockResolvedValueOnce(Buffer.from('ok'));
+        mockReadFile.mockRejectedValueOnce(new Error('ENOENT'));
+        const result = await computeHashes('/root', ['src/a.ts', 'src/deleted.ts']);
+        expect(result).toHaveProperty('src/a.ts');
+        expect(result).not.toHaveProperty('src/deleted.ts');
+    });
+});
+// ---------------------------------------------------------------------------
+// loadState
+// ---------------------------------------------------------------------------
+describe('loadState', () => {
+    it('returns null when state file does not exist', () => {
+        mockReadFileSync.mockImplementation(() => { throw new Error('ENOENT'); });
+        expect(loadState('/root', 'src/**/*.ts')).toBeNull();
+    });
+    it('returns null when state file contains invalid JSON', () => {
+        mockReadFileSync.mockReturnValue('{ invalid json }');
+        expect(loadState('/root', 'src/**/*.ts')).toBeNull();
+    });
+    it('returns null when pattern is not found in state file', () => {
+        const state = { 'other/**/*.ts': { headSha: 'abc', fileHashes: {} } };
+        mockReadFileSync.mockReturnValue(JSON.stringify(state));
+        expect(loadState('/root', 'src/**/*.ts')).toBeNull();
+    });
+    it('returns the pattern state when found', () => {
+        const patternState = {
+            headSha: 'a4872f4',
+            fileHashes: { 'src/a.ts': 'hash1' },
+        };
+        const stateFile = { 'src/**/*.ts': patternState };
+        mockReadFileSync.mockReturnValue(JSON.stringify(stateFile));
+        expect(loadState('/root', 'src/**/*.ts')).toEqual(patternState);
+    });
+    it('reads from .claude/on-changes-run/state.local.json in git root', () => {
+        mockReadFileSync.mockImplementation(() => { throw new Error('ENOENT'); });
+        loadState('/my/project', 'src/**/*.ts');
+        expect(mockReadFileSync).toHaveBeenCalledWith(join('/my/project', '.claude/on-changes-run/state.local.json'), 'utf-8');
+    });
+});
+// ---------------------------------------------------------------------------
+// saveState
+// ---------------------------------------------------------------------------
+describe('saveState', () => {
+    const patternState = { headSha: 'abc123', fileHashes: { 'src/a.ts': 'hash1' } };
+    it('creates a new state file when none exists', async () => {
+        mockReadFile.mockRejectedValue(new Error('ENOENT'));
+        await saveState('/root', 'src/**/*.ts', patternState);
+        const written = JSON.parse(vi.mocked(mockWriteFile).mock.calls[0][1]);
+        expect(written['src/**/*.ts']).toEqual(patternState);
+    });
+    it('merges into existing state file without overwriting other patterns', async () => {
+        const existing = { 'backend/**/*.kt': { headSha: 'def456', fileHashes: {} } };
+        mockReadFile.mockResolvedValue(JSON.stringify(existing));
+        await saveState('/root', 'src/**/*.ts', patternState);
+        const written = JSON.parse(vi.mocked(mockWriteFile).mock.calls[0][1]);
+        expect(written['backend/**/*.kt']).toEqual(existing['backend/**/*.kt']);
+        expect(written['src/**/*.ts']).toEqual(patternState);
+    });
+    it('overwrites the state for an existing pattern', async () => {
+        const oldState = { 'src/**/*.ts': { headSha: 'old', fileHashes: {} } };
+        mockReadFile.mockResolvedValue(JSON.stringify(oldState));
+        await saveState('/root', 'src/**/*.ts', patternState);
+        const written = JSON.parse(vi.mocked(mockWriteFile).mock.calls[0][1]);
+        expect(written['src/**/*.ts']).toEqual(patternState);
+    });
+    it('ensures the .claude/on-changes-run directory exists', async () => {
+        mockReadFile.mockRejectedValue(new Error('ENOENT'));
+        await saveState('/root', 'src/**/*.ts', patternState);
+        expect(mockMkdir).toHaveBeenCalledWith(join('/root', '.claude/on-changes-run'), { recursive: true });
+    });
+    it('writes to .claude/on-changes-run/state.local.json in git root', async () => {
+        mockReadFile.mockRejectedValue(new Error('ENOENT'));
+        await saveState('/my/project', 'src/**/*.ts', patternState);
+        expect(mockWriteFile).toHaveBeenCalledWith(join('/my/project', '.claude/on-changes-run/state.local.json'), expect.any(String));
+    });
+});

package/dist/cli.js

@@ -15,12 +15,14 @@ function parseCliArgs() {
         .requiredOption('--on <glob>', 'Glob pattern to match changed files against')
         .requiredOption('--exec <command>', 'Command to execute (repeatable, run in parallel)', collect, [])
         .option('--exec-timeout <seconds>', 'Timeout per command in seconds', '300')
+        .option('--files-separator <sep>', 'Separator used in ON_CHANGES_RUN_* env vars', '\n')
         .parse(process.argv);
     const opts = program.opts();
     return {
         on: opts.on,
         exec: opts.exec,
         execTimeout: parseInt(opts.execTimeout, 10),
+        filesSeparator: opts.filesSeparator,
     };
 }
 async function readStdin() {
@@ -68,9 +70,13 @@ async function main() {
         process.exit(0);
     }
     process.stderr.write(`on-changes-run: ${changedFiles.length} file(s) changed matching "${args.on}", running ${args.exec.length} command(s)\n`);
-    // Run all commands in parallel
+    // Run all commands in parallel, exposing file lists as env vars
     const timeoutMs = args.execTimeout * 1000;
-    const results = await executeAll(args.exec, timeoutMs);
+    const env = {
+        ON_CHANGES_RUN_DIFF_FILES: matchingFiles.join(args.filesSeparator),
+        ON_CHANGES_RUN_CHANGED_FILES: changedFiles.join(args.filesSeparator),
+    };
+    const results = await executeAll(args.exec, timeoutMs, env);
     const failures = results.filter((r) => r.exitCode !== 0);
     if (failures.length > 0) {
         printFailures(failures);

package/dist/executor.d.ts

@@ -1,7 +1,7 @@
 import type { CommandResult } from './types.js';
 /** Execute a single shell command and capture its output */
-export declare function executeCommand(command: string, timeoutMs: number): Promise<CommandResult>;
+export declare function executeCommand(command: string, timeoutMs: number, env?: Record<string, string>): Promise<CommandResult>;
 /** Execute multiple commands in parallel */
-export declare function executeAll(commands: string[], timeoutMs: number): Promise<CommandResult[]>;
+export declare function executeAll(commands: string[], timeoutMs: number, env?: Record<string, string>): Promise<CommandResult[]>;
 /** Print details of failed commands to stderr */
 export declare function printFailures(failures: CommandResult[]): void;

package/dist/executor.js

@@ -2,11 +2,12 @@ import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
 const execAsync = promisify(exec);
 /** Execute a single shell command and capture its output */
-export async function executeCommand(command, timeoutMs) {
+export async function executeCommand(command, timeoutMs, env = {}) {
     try {
         const { stdout, stderr } = await execAsync(command, {
             maxBuffer: 10 * 1024 * 1024,
             timeout: timeoutMs,
+            env: { ...process.env, ...env },
         });
         return { command, exitCode: 0, stdout, stderr };
     }
@@ -21,8 +22,8 @@ export async function executeCommand(command, timeoutMs) {
     }
 }
 /** Execute multiple commands in parallel */
-export async function executeAll(commands, timeoutMs) {
-    return Promise.all(commands.map((cmd) => executeCommand(cmd, timeoutMs)));
+export async function executeAll(commands, timeoutMs, env = {}) {
+    return Promise.all(commands.map((cmd) => executeCommand(cmd, timeoutMs, env)));
 }
 /** Print details of failed commands to stderr */
 export function printFailures(failures) {

package/dist/state.js

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
-const STATE_FILENAME = '.claude/on-changes-run.state.json';
+const STATE_FILENAME = '.claude/on-changes-run/state.local.json';
 /** Compute SHA-256 hash of a file's content on disk */
 export async function computeFileHash(absolutePath) {
     const content = await readFile(absolutePath);
@@ -46,7 +46,7 @@ export async function saveState(gitRoot, pattern, state) {
         // File doesn't exist yet, start fresh
     }
     stateFile[pattern] = state;
-    await mkdir(join(gitRoot, '.claude'), { recursive: true });
+    await mkdir(join(gitRoot, '.claude/on-changes-run'), { recursive: true });
     await writeFile(statePath, JSON.stringify(stateFile, null, 2) + '\n');
 }
 /** Find files that changed between two snapshots */

package/dist/types.d.ts

@@ -14,6 +14,7 @@ export interface CliArgs {
     on: string;
     exec: string[];
     execTimeout: number;
+    filesSeparator: string;
 }
 /** Result of running a single command */
 export interface CommandResult {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fcamblor/on-changes-run",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Claude Code lifecycle hook: run commands when file changes are detected",
   "license": "MIT",
   "author": {
@@ -15,7 +15,9 @@
   ],
   "scripts": {
     "build": "tsc",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "engines": {
     "node": ">=18.0.0"
@@ -27,6 +29,7 @@
   "devDependencies": {
     "typescript": "~5.8.0",
     "@types/node": "^22.0.0",
-    "@types/picomatch": "^3.0.0"
+    "@types/picomatch": "^3.0.0",
+    "vitest": "^3.0.0"
   }
 }