relay-ide 0.1.0

package/dist/test/gh-routes.test.js

@@ -0,0 +1,156 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { enrichBranches } from '../server/gh-routes.js';
+function makeExec(responses) {
+    return async (file, args, _opts) => {
+        const key = `${file} ${args.slice(0, 3).join(' ')}`;
+        for (const [pattern, response] of Object.entries(responses)) {
+            if (key.startsWith(pattern)) {
+                return { stdout: response.stdout, stderr: response.stderr ?? '' };
+            }
+        }
+        throw new Error(`unexpected exec: ${file} ${args.join(' ')}`);
+    };
+}
+describe('enrichBranches', () => {
+    it('returns PR + staleness per branch keyed by repoPath::branchName', async () => {
+        const prList = JSON.stringify([
+            {
+                number: 42,
+                title: 'Add login',
+                url: 'https://github.com/o/r/pull/42',
+                state: 'OPEN',
+                headRefName: 'feat/login',
+                baseRefName: 'main',
+                isDraft: false,
+                reviewDecision: 'APPROVED',
+                additions: 10,
+                deletions: 2,
+                mergeable: 'MERGEABLE',
+                updatedAt: new Date().toISOString(),
+            },
+        ]);
+        const results = await enrichBranches([{ repoPath: '/repos/my-repo', branchName: 'feat/login' }], makeExec({
+            'gh pr list': { stdout: prList },
+            'git rev-list': { stdout: '3\n' },
+        }));
+        const key = '/repos/my-repo::feat/login';
+        assert.ok(results[key], `expected key ${key} in results`);
+        assert.equal(results[key].pr.number, 42);
+        assert.equal(results[key].stale, false);
+    });
+    it('handles partial failure (one repo fails, others succeed)', async () => {
+        const prList = JSON.stringify([
+            {
+                number: 1,
+                title: 'Fix',
+                url: 'https://github.com/o/r/pull/1',
+                state: 'OPEN',
+                headRefName: 'fix/bug',
+                baseRefName: 'main',
+                isDraft: false,
+                reviewDecision: null,
+                additions: 1,
+                deletions: 1,
+                mergeable: 'MERGEABLE',
+                updatedAt: new Date().toISOString(),
+            },
+        ]);
+        const exec = async (file, args, opts) => {
+            if (opts.cwd === '/repos/bad-repo' && file === 'gh') {
+                throw new Error('gh: not logged in');
+            }
+            if (file === 'gh' && args[0] === 'pr' && args[1] === 'list') {
+                return { stdout: prList, stderr: '' };
+            }
+            if (file === 'git' && args[0] === 'rev-list') {
+                return { stdout: '1\n', stderr: '' };
+            }
+            throw new Error(`unexpected: ${file} ${args.join(' ')}`);
+        };
+        const results = await enrichBranches([
+            { repoPath: '/repos/good-repo', branchName: 'fix/bug' },
+            { repoPath: '/repos/bad-repo', branchName: 'feat/x' },
+        ], exec);
+        // Good repo should have data
+        assert.ok(results['/repos/good-repo::fix/bug']);
+        assert.equal(results['/repos/good-repo::fix/bug'].pr.number, 1);
+        // Bad repo should have null pr and default stale=false
+        assert.equal(results['/repos/bad-repo::feat/x'].pr, null);
+        assert.equal(results['/repos/bad-repo::feat/x'].stale, false);
+    });
+    it('returns empty results for empty input', async () => {
+        const results = await enrichBranches([], async () => ({
+            stdout: '',
+            stderr: '',
+        }));
+        assert.deepEqual(results, {});
+    });
+    it('degrades when gh CLI is missing (ENOENT)', async () => {
+        const exec = async (file, args) => {
+            if (file === 'gh') {
+                const err = new Error('spawn gh ENOENT');
+                err.code = 'ENOENT';
+                throw err;
+            }
+            if (file === 'git' && args[0] === 'rev-list') {
+                return { stdout: '0\n', stderr: '' };
+            }
+            throw new Error(`unexpected: ${file} ${args.join(' ')}`);
+        };
+        const results = await enrichBranches([{ repoPath: '/repos/my-repo', branchName: 'feat/x' }], exec);
+        const entry = results['/repos/my-repo::feat/x'];
+        assert.equal(entry.pr, null);
+        assert.equal(entry.stale, true); // 0 commits ahead = stale
+    });
+    it('batches PR lookups per unique repo (one gh call per repo)', async () => {
+        const callLog = [];
+        const prList = JSON.stringify([
+            {
+                number: 1,
+                title: 'A',
+                url: 'u',
+                state: 'OPEN',
+                headRefName: 'a',
+                baseRefName: 'main',
+                isDraft: false,
+                reviewDecision: null,
+                additions: 0,
+                deletions: 0,
+                mergeable: 'MERGEABLE',
+                updatedAt: new Date().toISOString(),
+            },
+            {
+                number: 2,
+                title: 'B',
+                url: 'u',
+                state: 'OPEN',
+                headRefName: 'b',
+                baseRefName: 'main',
+                isDraft: false,
+                reviewDecision: null,
+                additions: 0,
+                deletions: 0,
+                mergeable: 'MERGEABLE',
+                updatedAt: new Date().toISOString(),
+            },
+        ]);
+        const exec = async (file, args, opts) => {
+            callLog.push(`${file} ${args[0]} ${args[1] ?? ''} [${opts.cwd}]`);
+            if (file === 'gh' && args[0] === 'pr' && args[1] === 'list') {
+                return { stdout: prList, stderr: '' };
+            }
+            if (file === 'git' && args[0] === 'rev-list') {
+                return { stdout: '1\n', stderr: '' };
+            }
+            throw new Error(`unexpected`);
+        };
+        await enrichBranches([
+            { repoPath: '/repos/repo1', branchName: 'a' },
+            { repoPath: '/repos/repo1', branchName: 'b' },
+        ], exec);
+        // Should have exactly 1 gh pr list call for repo1 (not 2)
+        const ghCalls = callLog.filter((c) => c.startsWith('gh pr list'));
+        assert.equal(ghCalls.length, 1, `expected 1 gh pr list call, got ${ghCalls.length}`);
+    });
+});

package/dist/test/git-changed-files.test.js

@@ -0,0 +1,152 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { getChangedFiles, getFileDiff, getDefaultBranch, } from '../server/git.js';
+describe('getChangedFiles', () => {
+    it('parses working tree changes from git status + numstat', async () => {
+        const files = await getChangedFiles('/tmp/repo', undefined, async (file, args, _opts) => {
+            if (args[0] === 'status') {
+                return {
+                    stdout: ' M server/git.ts\0?? frontend/new.svelte\0 D old-file.js\0',
+                    stderr: '',
+                };
+            }
+            if (args[0] === 'diff' && args.includes('--numstat')) {
+                return { stdout: '15\t3\tserver/git.ts\n', stderr: '' };
+            }
+            if (file === 'wc') {
+                return { stdout: '      42 frontend/new.svelte', stderr: '' };
+            }
+            return { stdout: '', stderr: '' };
+        });
+        assert.equal(files.length, 3);
+        const gitTs = files.find((f) => f.path === 'server/git.ts');
+        assert.ok(gitTs);
+        assert.equal(gitTs.status, 'modified');
+        assert.equal(gitTs.additions, 15);
+        assert.equal(gitTs.deletions, 3);
+        assert.equal(gitTs.directory, 'server');
+        const newFile = files.find((f) => f.path === 'frontend/new.svelte');
+        assert.ok(newFile);
+        assert.equal(newFile.status, 'untracked');
+        assert.equal(newFile.additions, 42);
+        assert.equal(newFile.directory, 'frontend');
+        const deleted = files.find((f) => f.path === 'old-file.js');
+        assert.ok(deleted);
+        assert.equal(deleted.status, 'deleted');
+        assert.equal(deleted.directory, '.');
+    });
+    it('parses branch comparison with renames', async () => {
+        const files = await getChangedFiles('/tmp/repo', 'main', async (_file, args, _opts) => {
+            if (args[0] === 'diff' && args.includes('--name-status')) {
+                return {
+                    stdout: 'M\tserver/git.ts\nA\tnew-file.ts\nR100\told-name.ts\tnew-name.ts\n',
+                    stderr: '',
+                };
+            }
+            if (args[0] === 'diff' && args.includes('--numstat')) {
+                return {
+                    stdout: '10\t2\tserver/git.ts\n50\t0\tnew-file.ts\n5\t5\tnew-name.ts\n',
+                    stderr: '',
+                };
+            }
+            return { stdout: '', stderr: '' };
+        });
+        assert.equal(files.length, 3);
+        const renamed = files.find((f) => f.path === 'new-name.ts');
+        assert.ok(renamed);
+        assert.equal(renamed.status, 'renamed');
+        assert.equal(renamed.oldPath, 'old-name.ts');
+    });
+    it('throws on git failure', async () => {
+        await assert.rejects(() => getChangedFiles('/tmp/repo', undefined, async () => {
+            throw new Error('not a git repo');
+        }), { message: 'not a git repo' });
+    });
+});
+describe('getFileDiff', () => {
+    it('returns working tree diff for a file', async () => {
+        const diff = await getFileDiff('/tmp/repo', 'server/git.ts', undefined, async (_file, args) => {
+            assert.equal(args[0], 'diff');
+            assert.ok(args.includes('--unified=3'));
+            assert.ok(args.includes('--find-renames'));
+            assert.ok(args.includes('--'));
+            assert.ok(args.includes('server/git.ts'));
+            return {
+                stdout: 'diff --git a/server/git.ts b/server/git.ts\n--- a/server/git.ts\n+++ b/server/git.ts\n@@ -1,3 +1,4 @@\n+new line\n old\n',
+                stderr: '',
+            };
+        });
+        assert.ok(diff.includes('new line'));
+    });
+    it('returns staged diff when base is "cached"', async () => {
+        const diff = await getFileDiff('/tmp/repo', 'file.ts', 'cached', async (_file, args) => {
+            assert.ok(args.includes('--cached'));
+            return { stdout: 'staged diff output', stderr: '' };
+        });
+        assert.equal(diff, 'staged diff output');
+    });
+    it('returns branch comparison diff', async () => {
+        const diff = await getFileDiff('/tmp/repo', 'file.ts', 'main', async (_file, args) => {
+            assert.ok(args.includes('main...HEAD'));
+            return { stdout: 'branch diff output', stderr: '' };
+        });
+        assert.equal(diff, 'branch diff output');
+    });
+    it('falls back to --no-index for untracked files when first diff is empty', async () => {
+        let callCount = 0;
+        const diff = await getFileDiff('/tmp/repo', 'new-file.ts', undefined, async (_file, args) => {
+            callCount++;
+            if (callCount === 1) {
+                // First call: git diff returns empty (untracked file)
+                return { stdout: '', stderr: '' };
+            }
+            // Second call: git diff --no-index exits with code 1 but has stdout
+            assert.ok(args.includes('--no-index'));
+            const err = new Error('exit code 1');
+            err.stdout =
+                'diff --git a/dev/null b/new-file.ts\n+++ b/new-file.ts\n+content\n';
+            throw err;
+        });
+        assert.ok(diff.includes('+content'));
+        assert.equal(callCount, 2);
+    });
+    it('throws on git failure', async () => {
+        await assert.rejects(() => getFileDiff('/tmp/repo', 'file.ts', undefined, async () => {
+            throw new Error('git failed');
+        }), { message: 'git failed' });
+    });
+});
+describe('getDefaultBranch', () => {
+    it('returns default branch from symbolic-ref', async () => {
+        const branch = await getDefaultBranch('/tmp/repo', async (_file, args) => {
+            if (args[0] === 'symbolic-ref') {
+                return { stdout: 'refs/remotes/origin/main\n', stderr: '' };
+            }
+            return { stdout: '', stderr: '' };
+        });
+        assert.equal(branch, 'main');
+    });
+    it('falls back to checking rev-parse for main then master', async () => {
+        const branch = await getDefaultBranch('/tmp/repo', async (_file, args) => {
+            if (args[0] === 'symbolic-ref') {
+                throw new Error('not set');
+            }
+            if (args[0] === 'rev-parse' && args[1] === '--verify') {
+                if (args[2] === 'refs/heads/main') {
+                    throw new Error('not found');
+                }
+                if (args[2] === 'refs/heads/master') {
+                    return { stdout: 'abc123\n', stderr: '' };
+                }
+            }
+            return { stdout: '', stderr: '' };
+        });
+        assert.equal(branch, 'master');
+    });
+    it('returns "main" as ultimate fallback', async () => {
+        const branch = await getDefaultBranch('/tmp/repo', async () => {
+            throw new Error('everything fails');
+        });
+        assert.equal(branch, 'main');
+    });
+});

package/dist/test/git-routes.test.js

@@ -0,0 +1,146 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { scanWorktrees } from '../server/git-routes.js';
+function makeDeps(overrides = {}) {
+    return {
+        getConfig: () => ({ rootDirs: ['/repos'], repos: [] }),
+        configPath: '/tmp/test-config.json',
+        execFileAsync: async () => ({ stdout: '', stderr: '' }),
+        readdirSync: () => [],
+        statSync: () => ({ isDirectory: () => true }),
+        readMeta: () => null,
+        ...overrides,
+    };
+}
+describe('scanWorktrees', () => {
+    it('returns worktrees without PR data (no branchState, prNumber, prTitle)', async () => {
+        const deps = makeDeps({
+            getConfig: () => ({ rootDirs: ['/repos'], repos: [] }),
+            execFileAsync: async (file, args, opts) => {
+                if (file === 'git' && args[0] === 'worktree') {
+                    return {
+                        stdout: [
+                            `worktree ${opts.cwd}`,
+                            'HEAD abc123',
+                            'branch refs/heads/main',
+                            '',
+                            `worktree ${opts.cwd}/.worktrees/feat`,
+                            'HEAD def456',
+                            'branch refs/heads/feat/login',
+                            '',
+                        ].join('\n'),
+                        stderr: '',
+                    };
+                }
+                throw new Error(`unexpected: ${file} ${args.join(' ')}`);
+            },
+            readdirSync: (_dir) => [
+                { name: 'my-repo', isDirectory: () => true },
+            ],
+            statSync: () => ({ isDirectory: () => true }),
+        });
+        const items = await scanWorktrees(deps);
+        assert.ok(Array.isArray(items));
+        // parseWorktreeListPorcelain excludes the main worktree, so only child worktrees are returned
+        assert.equal(items.length, 1);
+        assert.equal(items[0].branchName, 'feat/login');
+        for (const wt of items) {
+            assert.equal(wt.branchState, undefined);
+            assert.equal(wt.prNumber, undefined);
+            assert.equal(wt.prTitle, undefined);
+            assert.ok(typeof wt.path === 'string');
+            assert.ok(typeof wt.branchName === 'string');
+        }
+    });
+    it('handles empty rootDirs gracefully', async () => {
+        const deps = makeDeps({
+            getConfig: () => ({ rootDirs: [], repos: [] }),
+        });
+        const items = await scanWorktrees(deps);
+        assert.deepEqual(items, []);
+    });
+    it('filters by repo param', async () => {
+        const deps = makeDeps({
+            execFileAsync: async (file, args, opts) => {
+                if (file === 'git' && args[0] === 'worktree') {
+                    return {
+                        stdout: [
+                            `worktree ${opts.cwd}`,
+                            'HEAD abc123',
+                            'branch refs/heads/main',
+                            '',
+                            `worktree ${opts.cwd}/.worktrees/feat`,
+                            'HEAD def456',
+                            'branch refs/heads/feat/x',
+                            '',
+                        ].join('\n'),
+                        stderr: '',
+                    };
+                }
+                throw new Error(`unexpected: ${file} ${args.join(' ')}`);
+            },
+        });
+        // parseWorktreeListPorcelain excludes the main worktree, so only the child is returned
+        const items = await scanWorktrees(deps, '/repos/my-repo');
+        assert.ok(Array.isArray(items));
+        assert.equal(items.length, 1);
+        assert.equal(items[0].branchName, 'feat/x');
+    });
+    it('deduplicates worktrees appearing via multiple repos', async () => {
+        const sharedWorktreePath = '/repos/my-repo/.worktrees/feat';
+        const deps = makeDeps({
+            getConfig: () => ({
+                rootDirs: ['/repos'],
+                repos: ['/repos/my-repo'],
+            }),
+            execFileAsync: async (file, args, opts) => {
+                if (file === 'git' && args[0] === 'worktree') {
+                    return {
+                        stdout: [
+                            `worktree ${opts.cwd}`,
+                            'HEAD abc123',
+                            'branch refs/heads/main',
+                            '',
+                            `worktree ${sharedWorktreePath}`,
+                            'HEAD def456',
+                            'branch refs/heads/feat/x',
+                            '',
+                        ].join('\n'),
+                        stderr: '',
+                    };
+                }
+                throw new Error(`unexpected: ${file} ${args.join(' ')}`);
+            },
+            readdirSync: () => [{ name: 'my-repo', isDirectory: () => true }],
+            statSync: () => ({ isDirectory: () => true }),
+        });
+        const items = await scanWorktrees(deps);
+        const paths = items.map((wt) => wt.path);
+        const uniquePaths = [...new Set(paths)];
+        assert.equal(paths.length, uniquePaths.length, 'should have no duplicate paths');
+    });
+    it('falls back to directory scanning when git worktree list fails', async () => {
+        const deps = makeDeps({
+            getConfig: () => ({ rootDirs: ['/repos'], repos: [] }),
+            execFileAsync: async () => {
+                throw new Error('git worktree list failed');
+            },
+            readdirSync: (dir) => {
+                if (dir === '/repos')
+                    return [{ name: 'my-repo', isDirectory: () => true }];
+                if (dir.includes('.worktrees'))
+                    return [{ name: 'feat-branch', isDirectory: () => true }];
+                return [];
+            },
+            statSync: () => ({ isDirectory: () => true }),
+            readMeta: () => ({
+                worktreePath: '/repos/my-repo/.worktrees/feat-branch',
+                displayName: 'Feature',
+                lastActivity: '',
+                branchName: 'feat-branch',
+            }),
+        });
+        const items = await scanWorktrees(deps);
+        assert.ok(items.length > 0, 'should fall back to directory scanning');
+    });
+});

package/dist/test/git-utils.test.js

@@ -0,0 +1,68 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { extractOwnerRepo } from '../server/git.js';
+import { isStalePr } from '../server/gh.js';
+describe('extractOwnerRepo', () => {
+    it('parses an SSH URL with .git suffix', () => {
+        assert.equal(extractOwnerRepo('git@github.com:donovan-yohan/claude-remote-cli.git'), 'donovan-yohan/claude-remote-cli');
+    });
+    it('parses an SSH URL without .git suffix', () => {
+        assert.equal(extractOwnerRepo('git@github.com:owner/repo'), 'owner/repo');
+    });
+    it('parses an HTTPS URL with .git suffix', () => {
+        assert.equal(extractOwnerRepo('https://github.com/owner/repo.git'), 'owner/repo');
+    });
+    it('parses an HTTPS URL without .git suffix', () => {
+        assert.equal(extractOwnerRepo('https://github.com/owner/repo'), 'owner/repo');
+    });
+    it('is host-agnostic and parses a non-GitHub HTTPS URL', () => {
+        assert.equal(extractOwnerRepo('https://gitlab.com/owner/repo.git'), 'owner/repo');
+    });
+    it('returns null for an empty string', () => {
+        assert.equal(extractOwnerRepo(''), null);
+    });
+    it('returns null for a malformed URL', () => {
+        assert.equal(extractOwnerRepo('not-a-url'), null);
+    });
+});
+function makePr(overrides = {}) {
+    return {
+        number: 1,
+        title: 'test',
+        url: '',
+        state: 'OPEN',
+        headRefName: 'main',
+        baseRefName: 'main',
+        isDraft: false,
+        reviewDecision: null,
+        additions: 0,
+        deletions: 0,
+        mergeable: 'UNKNOWN',
+        unresolvedCommentCount: 0,
+        updatedAt: '',
+        ...overrides,
+    };
+}
+describe('isStalePr', () => {
+    it('OPEN PR is never stale regardless of age', () => {
+        assert.equal(isStalePr(makePr({ state: 'OPEN', updatedAt: '2020-01-01T00:00:00Z' })), false);
+    });
+    it('MERGED PR updated more than 1 day ago is stale', () => {
+        const twoDaysAgo = new Date(Date.now() - 2 * 86_400_000).toISOString();
+        assert.equal(isStalePr(makePr({ state: 'MERGED', updatedAt: twoDaysAgo })), true);
+    });
+    it('CLOSED PR updated more than 1 day ago is stale', () => {
+        const twoDaysAgo = new Date(Date.now() - 2 * 86_400_000).toISOString();
+        assert.equal(isStalePr(makePr({ state: 'CLOSED', updatedAt: twoDaysAgo })), true);
+    });
+    it('MERGED PR updated less than 1 day ago is not stale (grace period)', () => {
+        const oneHourAgo = new Date(Date.now() - 3_600_000).toISOString();
+        assert.equal(isStalePr(makePr({ state: 'MERGED', updatedAt: oneHourAgo })), false);
+    });
+    it('PR with empty updatedAt is stale', () => {
+        assert.equal(isStalePr(makePr({ state: 'MERGED', updatedAt: '' })), true);
+    });
+    it('PR with unparseable updatedAt is stale', () => {
+        assert.equal(isStalePr(makePr({ state: 'CLOSED', updatedAt: 'not-a-date' })), true);
+    });
+});

package/dist/test/git-watcher.test.js

@@ -0,0 +1,110 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { GitWatcher } from '../server/watcher.js';
+let tmpDir;
+let repoDir;
+before(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'git-watcher-test-'));
+    repoDir = path.join(tmpDir, 'repo');
+    fs.mkdirSync(path.join(repoDir, '.git'), { recursive: true });
+    fs.mkdirSync(path.join(repoDir, 'src'), { recursive: true });
+    fs.mkdirSync(path.join(repoDir, 'node_modules', 'dep'), { recursive: true });
+    // Create a HEAD file so the HEAD watcher can attach
+    fs.writeFileSync(path.join(repoDir, '.git', 'HEAD'), 'ref: refs/heads/main\n');
+});
+after(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+describe('GitWatcher', () => {
+    it('emits files-changed when a working-tree file changes', async () => {
+        const watcher = new GitWatcher();
+        let emitted = false;
+        let emittedPath = '';
+        watcher.on('files-changed', (data) => {
+            emitted = true;
+            emittedPath = data.workspacePath;
+        });
+        watcher.watch(repoDir);
+        // Write a source file (should trigger)
+        fs.writeFileSync(path.join(repoDir, 'src', 'index.ts'), 'export {}');
+        // Wait for debounce (1000ms) + buffer
+        await new Promise((resolve) => setTimeout(resolve, 1500));
+        assert.ok(emitted, 'should emit files-changed for working-tree file');
+        assert.equal(emittedPath, repoDir);
+        watcher.close();
+    });
+    it('does NOT emit for .git/ changes', async () => {
+        const watcher = new GitWatcher();
+        let emitCount = 0;
+        watcher.on('files-changed', () => {
+            emitCount++;
+        });
+        watcher.watch(repoDir);
+        // Write to .git/ (should be filtered)
+        fs.writeFileSync(path.join(repoDir, '.git', 'index'), 'fake');
+        await new Promise((resolve) => setTimeout(resolve, 1500));
+        // The HEAD watcher may fire from the before() setup, so we only check
+        // that .git/index specifically doesn't cause extra emissions.
+        // Reset and test again cleanly.
+        const countBefore = emitCount;
+        fs.writeFileSync(path.join(repoDir, '.git', 'index'), 'fake2');
+        await new Promise((resolve) => setTimeout(resolve, 1500));
+        assert.equal(emitCount, countBefore, 'should not emit for .git/index changes');
+        watcher.close();
+    });
+    it('does NOT emit for node_modules/ changes', async () => {
+        const watcher = new GitWatcher();
+        let emitted = false;
+        // Wait for any initial events to settle
+        watcher.watch(repoDir);
+        await new Promise((resolve) => setTimeout(resolve, 1500));
+        watcher.on('files-changed', () => {
+            emitted = true;
+        });
+        fs.writeFileSync(path.join(repoDir, 'node_modules', 'dep', 'index.js'), 'module.exports = {}');
+        await new Promise((resolve) => setTimeout(resolve, 1500));
+        assert.ok(!emitted, 'should not emit for node_modules/ changes');
+        watcher.close();
+    });
+    it('emits when .git/HEAD changes (commit or branch switch)', async () => {
+        const watcher = new GitWatcher();
+        let emitted = false;
+        watcher.watch(repoDir);
+        // Let initial events settle
+        await new Promise((resolve) => setTimeout(resolve, 1500));
+        watcher.on('files-changed', () => {
+            emitted = true;
+        });
+        // Simulate a branch switch
+        fs.writeFileSync(path.join(repoDir, '.git', 'HEAD'), 'ref: refs/heads/feature\n');
+        await new Promise((resolve) => setTimeout(resolve, 1500));
+        assert.ok(emitted, 'should emit when .git/HEAD changes');
+        watcher.close();
+    });
+    it('does not emit after close()', async () => {
+        const watcher = new GitWatcher();
+        let emitCount = 0;
+        watcher.on('files-changed', () => {
+            emitCount++;
+        });
+        watcher.watch(repoDir);
+        watcher.close();
+        fs.writeFileSync(path.join(repoDir, 'src', 'closed.ts'), 'export {}');
+        await new Promise((resolve) => setTimeout(resolve, 1500));
+        assert.equal(emitCount, 0);
+    });
+    it('deduplicates watchers for the same path via refCount', () => {
+        const watcher = new GitWatcher();
+        watcher.watch(repoDir);
+        watcher.watch(repoDir);
+        // Should not throw, refCount = 2
+        watcher.unwatch(repoDir);
+        // Still watching (refCount = 1)
+        watcher.unwatch(repoDir);
+        // Now closed (refCount = 0)
+        watcher.close();
+    });
+});