shadow-git 0.1.0 → 1.0.3

package/tests/core/gitignore.test.ts

@@ -0,0 +1,561 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { writeFile, mkdir, readFile } from 'node:fs/promises';
+import {
+  accessSync,
+  constants,
+  writeFileSync,
+  unlinkSync,
+  renameSync,
+} from 'node:fs';
+import { join, resolve } from 'node:path';
+import { spawnSync, spawn } from 'node:child_process';
+import { createTempGitRepo, removeTempDir } from '../helpers';
+import { trackInit } from '../../src/commands/track/init';
+import { trackAdd } from '../../src/commands/track/add';
+import {
+  disableGitignores,
+  enableGitignores,
+  findStaleGitignores,
+  isGuardActive,
+  setupGitignoreGuard,
+} from '../../src/core/gitignore';
+import { StaleGitignoreError } from '../../src/core/errors';
+
+const HELPER_SCRIPT = resolve('tests/helpers/guard-child.mjs');
+
+function fileExists(path: string): boolean {
+  try {
+    accessSync(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+describe('gitignore manipulator', () => {
+  let tempDir: string;
+  const originalCwd = process.cwd();
+
+  beforeEach(async () => {
+    tempDir = await createTempGitRepo();
+    process.chdir(tempDir);
+    await trackInit();
+
+    // Create a tracked directory with a .gitignore inside
+    await mkdir(join(tempDir, 'secret'), { recursive: true });
+    await writeFile(join(tempDir, 'secret', '.gitignore'), 'local-only\n');
+    await writeFile(join(tempDir, 'secret', 'data.txt'), 'secret data');
+    await trackAdd(['secret']);
+  });
+
+  afterEach(async () => {
+    process.chdir(originalCwd);
+    await removeTempDir(tempDir);
+  });
+
+  // ---------------------------------------------------------------
+  // disableGitignores
+  // ---------------------------------------------------------------
+  describe('disableGitignores', () => {
+    it('renames .gitignore to .gitignore-sgit.bat in tracked directory', () => {
+      const disabled = disableGitignores(tempDir, ['secret/']);
+      expect(disabled).toContain('secret/.gitignore');
+      expect(fileExists(join(tempDir, 'secret', '.gitignore'))).toBe(false);
+      expect(fileExists(join(tempDir, 'secret', '.gitignore-sgit.bat'))).toBe(
+        true,
+      );
+    });
+
+    it('handles nested .gitignore files in tracked directory', async () => {
+      await mkdir(join(tempDir, 'secret', 'sub'), { recursive: true });
+      await writeFile(
+        join(tempDir, 'secret', 'sub', '.gitignore'),
+        'nested\n',
+      );
+
+      const disabled = disableGitignores(tempDir, ['secret/']);
+      expect(disabled).toContain('secret/.gitignore');
+      expect(disabled).toContain('secret/sub/.gitignore');
+    });
+
+    it('disables ancestor .gitignore for file entries', async () => {
+      // secret/data.txt is a file entry — its parent secret/ has a .gitignore
+      const disabled = disableGitignores(tempDir, ['secret/data.txt']);
+      expect(disabled).toContain('secret/.gitignore');
+      expect(fileExists(join(tempDir, 'secret', '.gitignore'))).toBe(false);
+    });
+
+    it('disables root .gitignore for any manifest path', async () => {
+      await writeFile(join(tempDir, '.gitignore'), '*.log\n');
+      const disabled = disableGitignores(tempDir, ['secret/']);
+      expect(disabled).toContain('.gitignore');
+      expect(fileExists(join(tempDir, '.gitignore'))).toBe(false);
+    });
+
+    it('disables root .gitignore for root-level file entries', async () => {
+      await writeFile(join(tempDir, '.gitignore'), '*.log\n');
+      const disabled = disableGitignores(tempDir, ['README.md']);
+      expect(disabled).toContain('.gitignore');
+    });
+
+    it('disables all ancestor .gitignore files for deep file path', async () => {
+      await mkdir(join(tempDir, 'a', 'b', 'c'), { recursive: true });
+      await writeFile(join(tempDir, 'a', '.gitignore'), 'a-ignore\n');
+      await writeFile(join(tempDir, 'a', 'b', '.gitignore'), 'b-ignore\n');
+      await writeFile(join(tempDir, 'a', 'b', 'c', '.gitignore'), 'c-ignore\n');
+      await writeFile(join(tempDir, 'a', 'b', 'c', 'file.txt'), 'data');
+
+      const disabled = disableGitignores(tempDir, ['a/b/c/file.txt']);
+      expect(disabled).toContain('a/.gitignore');
+      expect(disabled).toContain('a/b/.gitignore');
+      expect(disabled).toContain('a/b/c/.gitignore');
+    });
+
+    it('ignores .gitignore files in unrelated directories', async () => {
+      await mkdir(join(tempDir, 'other'), { recursive: true });
+      await writeFile(join(tempDir, 'other', '.gitignore'), 'stuff\n');
+
+      const disabled = disableGitignores(tempDir, ['secret/']);
+      expect(disabled).not.toContain('other/.gitignore');
+      expect(fileExists(join(tempDir, 'other', '.gitignore'))).toBe(true);
+    });
+
+    it('does not affect sibling subdirectory .gitignore', async () => {
+      // test/1 is tracked but test/test2/.gitignore should NOT be affected
+      await mkdir(join(tempDir, 'test', 'test2'), { recursive: true });
+      await writeFile(join(tempDir, 'test', '.gitignore'), 'test-gi\n');
+      await writeFile(join(tempDir, 'test', 'test2', '.gitignore'), 'test2-gi\n');
+      await writeFile(join(tempDir, 'test', '1'), 'data');
+
+      const disabled = disableGitignores(tempDir, ['test/1']);
+      expect(disabled).toContain('test/.gitignore');
+      expect(disabled).not.toContain('test/test2/.gitignore');
+      expect(fileExists(join(tempDir, 'test', 'test2', '.gitignore'))).toBe(true);
+    });
+
+    it('returns empty array when no .gitignore files found', () => {
+      unlinkSync(join(tempDir, 'secret', '.gitignore'));
+      const disabled = disableGitignores(tempDir, ['secret/']);
+      expect(disabled).toEqual([]);
+    });
+
+    it('throws StaleGitignoreError when .gitignore-sgit.bat already exists', async () => {
+      await writeFile(
+        join(tempDir, 'secret', '.gitignore-sgit.bat'),
+        'stale\n',
+      );
+      expect(() => disableGitignores(tempDir, ['secret/'])).toThrow(
+        StaleGitignoreError,
+      );
+    });
+
+    it('matches .temp folder scenario exactly', async () => {
+      // Reproduce the .temp manifest:
+      // ["temp.md", "README.md", "temp/should-track", "temp2/", "test/1", "rec1/rec2/test"]
+      //
+      // Should disable: root, temp/, temp2/, temp2/temp3/, test/, rec1/, rec1/rec2/
+      // Should NOT disable: iii/, test/test2/
+      await writeFile(join(tempDir, '.gitignore'), 'root-gi\n');
+      await writeFile(join(tempDir, 'temp.md'), 'data');
+      await writeFile(join(tempDir, 'README.md'), 'data');
+
+      await mkdir(join(tempDir, 'temp'), { recursive: true });
+      await writeFile(join(tempDir, 'temp', '.gitignore'), 'temp-gi\n');
+      await writeFile(join(tempDir, 'temp', 'should-track'), 'data');
+
+      await mkdir(join(tempDir, 'temp2', 'temp3'), { recursive: true });
+      await writeFile(join(tempDir, 'temp2', '.gitignore'), 'temp2-gi\n');
+      await writeFile(join(tempDir, 'temp2', 'temp3', '.gitignore'), 'temp3-gi\n');
+
+      await mkdir(join(tempDir, 'test', 'test2'), { recursive: true });
+      await writeFile(join(tempDir, 'test', '.gitignore'), 'test-gi\n');
+      await writeFile(join(tempDir, 'test', 'test2', '.gitignore'), 'test2-gi\n');
+      await writeFile(join(tempDir, 'test', '1'), 'data');
+
+      await mkdir(join(tempDir, 'rec1', 'rec2'), { recursive: true });
+      await writeFile(join(tempDir, 'rec1', '.gitignore'), 'rec1-gi\n');
+      await writeFile(join(tempDir, 'rec1', 'rec2', '.gitignore'), 'rec2-gi\n');
+      await writeFile(join(tempDir, 'rec1', 'rec2', 'test'), 'data');
+
+      await mkdir(join(tempDir, 'iii'), { recursive: true });
+      await writeFile(join(tempDir, 'iii', '.gitignore'), 'iii-gi\n');
+
+      const manifest = [
+        'temp.md',
+        'README.md',
+        'temp/should-track',
+        'temp2/',
+        'test/1',
+        'rec1/rec2/test',
+      ];
+
+      const disabled = disableGitignores(tempDir, manifest);
+
+      // SHOULD be disabled (7):
+      expect(disabled).toContain('.gitignore');
+      expect(disabled).toContain('temp/.gitignore');
+      expect(disabled).toContain('temp2/.gitignore');
+      expect(disabled).toContain('temp2/temp3/.gitignore');
+      expect(disabled).toContain('test/.gitignore');
+      expect(disabled).toContain('rec1/.gitignore');
+      expect(disabled).toContain('rec1/rec2/.gitignore');
+
+      // SHOULD NOT be disabled (2):
+      expect(disabled).not.toContain('iii/.gitignore');
+      expect(disabled).not.toContain('test/test2/.gitignore');
+      expect(fileExists(join(tempDir, 'iii', '.gitignore'))).toBe(true);
+      expect(fileExists(join(tempDir, 'test', 'test2', '.gitignore'))).toBe(true);
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // enableGitignores
+  // ---------------------------------------------------------------
+  describe('enableGitignores', () => {
+    it('renames .gitignore-sgit.bat back to .gitignore', () => {
+      disableGitignores(tempDir, ['secret/']);
+      const enabled = enableGitignores(tempDir, ['secret/']);
+      expect(enabled).toHaveLength(1);
+      expect(fileExists(join(tempDir, 'secret', '.gitignore'))).toBe(true);
+      expect(fileExists(join(tempDir, 'secret', '.gitignore-sgit.bat'))).toBe(
+        false,
+      );
+    });
+
+    it('restores ancestor .gitignore for file entries', async () => {
+      await writeFile(join(tempDir, '.gitignore'), 'root\n');
+      disableGitignores(tempDir, ['secret/data.txt']);
+      enableGitignores(tempDir, ['secret/data.txt']);
+      expect(fileExists(join(tempDir, 'secret', '.gitignore'))).toBe(true);
+      expect(fileExists(join(tempDir, '.gitignore'))).toBe(true);
+    });
+
+    it('no-ops when no disabled files exist', () => {
+      const enabled = enableGitignores(tempDir, ['secret/']);
+      expect(enabled).toEqual([]);
+      expect(fileExists(join(tempDir, 'secret', '.gitignore'))).toBe(true);
+    });
+
+    it('preserves .gitignore content through disable/enable cycle', async () => {
+      const original = await readFile(
+        join(tempDir, 'secret', '.gitignore'),
+        'utf-8',
+      );
+      disableGitignores(tempDir, ['secret/']);
+      enableGitignores(tempDir, ['secret/']);
+      const restored = await readFile(
+        join(tempDir, 'secret', '.gitignore'),
+        'utf-8',
+      );
+      expect(restored).toBe(original);
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // findStaleGitignores
+  // ---------------------------------------------------------------
+  describe('findStaleGitignores', () => {
+    it('finds .gitignore-sgit.bat in tracked dirs', async () => {
+      await writeFile(
+        join(tempDir, 'secret', '.gitignore-sgit.bat'),
+        'stale\n',
+      );
+      const stale = findStaleGitignores(tempDir, ['secret/']);
+      expect(stale).toEqual(['secret/.gitignore-sgit.bat']);
+    });
+
+    it('finds .gitignore-sgit.bat in ancestor dirs for file entries', async () => {
+      await writeFile(
+        join(tempDir, 'secret', '.gitignore-sgit.bat'),
+        'stale\n',
+      );
+      const stale = findStaleGitignores(tempDir, ['secret/data.txt']);
+      expect(stale).toContain('secret/.gitignore-sgit.bat');
+    });
+
+    it('finds .gitignore-sgit.bat at root', async () => {
+      await writeFile(join(tempDir, '.gitignore-sgit.bat'), 'stale\n');
+      const stale = findStaleGitignores(tempDir, ['secret/']);
+      expect(stale).toContain('.gitignore-sgit.bat');
+    });
+
+    it('returns empty when no stale files exist', () => {
+      const stale = findStaleGitignores(tempDir, ['secret/']);
+      expect(stale).toEqual([]);
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // isGuardActive
+  // ---------------------------------------------------------------
+  describe('isGuardActive', () => {
+    it('returns false when no lock file', () => {
+      expect(isGuardActive(tempDir)).toBe(false);
+    });
+
+    it('returns true when lock file has current PID', () => {
+      const lockPath = join(tempDir, '.sgit', '.gitignore-guard');
+      writeFileSync(lockPath, String(process.pid));
+      expect(isGuardActive(tempDir)).toBe(true);
+      unlinkSync(lockPath);
+    });
+
+    it('returns false when lock file has dead PID', () => {
+      const lockPath = join(tempDir, '.sgit', '.gitignore-guard');
+      writeFileSync(lockPath, '99999999');
+      expect(isGuardActive(tempDir)).toBe(false);
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // setupGitignoreGuard — in-process tests
+  // ---------------------------------------------------------------
+  describe('setupGitignoreGuard', () => {
+    it('disables gitignores and returns cleanup function', () => {
+      const cleanup = setupGitignoreGuard(tempDir, ['secret/']);
+      expect(fileExists(join(tempDir, 'secret', '.gitignore'))).toBe(false);
+      expect(fileExists(join(tempDir, 'secret', '.gitignore-sgit.bat'))).toBe(
+        true,
+      );
+      expect(fileExists(join(tempDir, '.sgit', '.gitignore-guard'))).toBe(true);
+
+      cleanup();
+
+      expect(fileExists(join(tempDir, 'secret', '.gitignore'))).toBe(true);
+      expect(fileExists(join(tempDir, 'secret', '.gitignore-sgit.bat'))).toBe(
+        false,
+      );
+      expect(fileExists(join(tempDir, '.sgit', '.gitignore-guard'))).toBe(
+        false,
+      );
+    });
+
+    it('handles file entries with ancestor gitignores', async () => {
+      await writeFile(join(tempDir, '.gitignore'), 'root\n');
+      const cleanup = setupGitignoreGuard(tempDir, ['secret/data.txt']);
+
+      expect(fileExists(join(tempDir, 'secret', '.gitignore'))).toBe(false);
+      expect(fileExists(join(tempDir, '.gitignore'))).toBe(false);
+
+      cleanup();
+
+      expect(fileExists(join(tempDir, 'secret', '.gitignore'))).toBe(true);
+      expect(fileExists(join(tempDir, '.gitignore'))).toBe(true);
+    });
+
+    it('returns no-op when no gitignore files exist', () => {
+      unlinkSync(join(tempDir, 'secret', '.gitignore'));
+      const cleanup = setupGitignoreGuard(tempDir, ['secret/']);
+      expect(fileExists(join(tempDir, '.sgit', '.gitignore-guard'))).toBe(
+        false,
+      );
+      cleanup(); // should not throw
+    });
+
+    it('returns no-op for nested invocation (active lock)', () => {
+      const lockPath = join(tempDir, '.sgit', '.gitignore-guard');
+      writeFileSync(lockPath, String(process.pid));
+
+      const cleanup = setupGitignoreGuard(tempDir, ['secret/']);
+      // .gitignore should NOT be renamed
+      expect(fileExists(join(tempDir, 'secret', '.gitignore'))).toBe(true);
+      cleanup();
+      // Original lock still there
+      expect(fileExists(lockPath)).toBe(true);
+      unlinkSync(lockPath);
+    });
+
+    it('auto-cleans stale .bat files from a crashed process', () => {
+      renameSync(
+        join(tempDir, 'secret', '.gitignore'),
+        join(tempDir, 'secret', '.gitignore-sgit.bat'),
+      );
+      writeFileSync(
+        join(tempDir, '.sgit', '.gitignore-guard'),
+        '99999999', // dead PID
+      );
+
+      const cleanup = setupGitignoreGuard(tempDir, ['secret/']);
+      // Guard should have restored stale .bat, then re-disabled
+      expect(fileExists(join(tempDir, 'secret', '.gitignore-sgit.bat'))).toBe(
+        true,
+      );
+      cleanup();
+      expect(fileExists(join(tempDir, 'secret', '.gitignore'))).toBe(true);
+    });
+
+    it('cleanup is idempotent — calling twice does not throw', () => {
+      const cleanup = setupGitignoreGuard(tempDir, ['secret/']);
+      cleanup();
+      cleanup();
+      expect(fileExists(join(tempDir, 'secret', '.gitignore'))).toBe(true);
+    });
+
+    it('restores gitignores when used in try/finally after error', () => {
+      const cleanup = setupGitignoreGuard(tempDir, ['secret/']);
+      try {
+        throw new Error('simulated failure');
+      } catch {
+        // error caught
+      } finally {
+        cleanup();
+      }
+      expect(fileExists(join(tempDir, 'secret', '.gitignore'))).toBe(true);
+      expect(fileExists(join(tempDir, 'secret', '.gitignore-sgit.bat'))).toBe(
+        false,
+      );
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // Process termination scenarios (child process tests)
+  // ---------------------------------------------------------------
+  describe('guard restores gitignores on process termination', () => {
+    it('restores gitignores on successful exit', () => {
+      const r = runChild(tempDir, 'success');
+      expect(r.status).toBe(0);
+      assertGitignoreRestored(tempDir);
+    });
+
+    it('restores gitignores on uncaught exception', () => {
+      const r = runChild(tempDir, 'throw');
+      expect(r.status).not.toBe(0);
+      assertGitignoreRestored(tempDir);
+    });
+
+    it('restores gitignores on process.exit(1)', () => {
+      const r = runChild(tempDir, 'exit1');
+      expect(r.status).toBe(1);
+      assertGitignoreRestored(tempDir);
+    });
+
+    it('restores gitignores on SIGINT (Ctrl+C)', () => {
+      runChild(tempDir, 'sigint');
+      assertGitignoreRestored(tempDir);
+    });
+
+    it('restores gitignores on SIGTERM', () => {
+      runChild(tempDir, 'sigterm');
+      assertGitignoreRestored(tempDir);
+    });
+
+    it('restores gitignores when killed externally with SIGTERM (timeout)', () => {
+      runChildWithExternalKill(tempDir, 'SIGTERM');
+      assertGitignoreRestored(tempDir);
+    });
+
+    it('restores gitignores on git error (non-zero exit from git)', () => {
+      const r = runChild(tempDir, 'git-error');
+      expect(r.status).not.toBe(0);
+      assertGitignoreRestored(tempDir);
+    });
+
+    it('restores gitignores on SgitError (thrown application error)', () => {
+      const r = runChild(tempDir, 'sgit-error');
+      expect(r.status).not.toBe(0);
+      assertGitignoreRestored(tempDir);
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // .gitignore-sgit.bat must never persist
+  // ---------------------------------------------------------------
+  describe('.gitignore-sgit.bat must not exist after any sgit command', () => {
+    it('does not exist after successful guard lifecycle', () => {
+      const cleanup = setupGitignoreGuard(tempDir, ['secret/']);
+      cleanup();
+      expect(findStaleGitignores(tempDir, ['secret/'])).toEqual([]);
+    });
+
+    it('does not exist after guard cleanup from thrown error', () => {
+      const cleanup = setupGitignoreGuard(tempDir, ['secret/']);
+      try {
+        throw new Error('simulated failure');
+      } catch {
+        // error caught
+      } finally {
+        cleanup();
+      }
+      expect(findStaleGitignores(tempDir, ['secret/'])).toEqual([]);
+    });
+
+    it('disableGitignores throws when .gitignore-sgit.bat already exists', async () => {
+      await writeFile(
+        join(tempDir, 'secret', '.gitignore-sgit.bat'),
+        'stale content\n',
+      );
+      expect(() => disableGitignores(tempDir, ['secret/'])).toThrow(
+        StaleGitignoreError,
+      );
+      expect(() => disableGitignores(tempDir, ['secret/'])).toThrow(
+        /stale .gitignore-sgit.bat/,
+      );
+    });
+
+    it('guard auto-recovers stale files then proceeds normally', () => {
+      renameSync(
+        join(tempDir, 'secret', '.gitignore'),
+        join(tempDir, 'secret', '.gitignore-sgit.bat'),
+      );
+      writeFileSync(
+        join(tempDir, '.sgit', '.gitignore-guard'),
+        '99999999',
+      );
+
+      const cleanup = setupGitignoreGuard(tempDir, ['secret/']);
+      cleanup();
+
+      expect(fileExists(join(tempDir, 'secret', '.gitignore'))).toBe(true);
+      expect(fileExists(join(tempDir, 'secret', '.gitignore-sgit.bat'))).toBe(
+        false,
+      );
+      expect(findStaleGitignores(tempDir, ['secret/'])).toEqual([]);
+    });
+  });
+});
+
+// --- Test helpers ---
+
+function assertGitignoreRestored(root: string): void {
+  expect(fileExists(join(root, 'secret', '.gitignore'))).toBe(true);
+  expect(fileExists(join(root, 'secret', '.gitignore-sgit.bat'))).toBe(false);
+  expect(fileExists(join(root, '.sgit', '.gitignore-guard'))).toBe(false);
+}
+
+function runChild(
+  root: string,
+  exitMode: string,
+): { status: number | null; signal: string | null } {
+  const result = spawnSync('node', [HELPER_SCRIPT, root, exitMode], {
+    stdio: 'ignore',
+    timeout: 10_000,
+    env: { ...process.env, NODE_OPTIONS: '' },
+  });
+  return { status: result.status, signal: result.signal };
+}
+
+function runChildWithExternalKill(
+  root: string,
+  signal: NodeJS.Signals,
+): void {
+  const child = spawn('node', [HELPER_SCRIPT, root, 'timeout'], {
+    stdio: 'ignore',
+    env: { ...process.env, NODE_OPTIONS: '' },
+  });
+
+  spawnSync('sleep', ['0.3']);
+
+  if (child.pid) {
+    process.kill(child.pid, signal);
+  }
+
+  const deadline = Date.now() + 5000;
+  while (Date.now() < deadline) {
+    try {
+      process.kill(child.pid!, 0);
+      spawnSync('sleep', ['0.05']);
+    } catch {
+      break;
+    }
+  }
+}

package/tests/core/hooks.test.ts

@@ -12,6 +12,7 @@ import { join } from 'node:path';
 import {
   installMainHook,
   installShadowHook,
+  installShadowSyncHooks,
   uninstallMainHook,
   getHookDir,
 } from '../../src/core/hooks';
@@ -154,6 +155,39 @@ describe('installShadowHook', () => {
   });
 });
 
+describe('installShadowSyncHooks', () => {
+  let root: string;
+
+  beforeEach(async () => {
+    root = await createTempGitRepo();
+  });
+
+  afterEach(async () => {
+    await removeTempDir(root);
+  });
+
+  it('creates post-merge and post-checkout hooks', async () => {
+    const sgitDir = join(root, '.sgit');
+    await mkdir(sgitDir, { recursive: true });
+
+    await installShadowSyncHooks(sgitDir);
+
+    const postMerge = await readFile(
+      join(sgitDir, 'hooks', 'post-merge'),
+      'utf-8',
+    );
+    expect(postMerge).toContain('sgit track sync');
+    await access(join(sgitDir, 'hooks', 'post-merge'), constants.X_OK);
+
+    const postCheckout = await readFile(
+      join(sgitDir, 'hooks', 'post-checkout'),
+      'utf-8',
+    );
+    expect(postCheckout).toContain('sgit track sync');
+    await access(join(sgitDir, 'hooks', 'post-checkout'), constants.X_OK);
+  });
+});
+
 describe('uninstallMainHook', () => {
   let root: string;
 

package/tests/core/paths.test.ts

@@ -110,4 +110,28 @@ describe('isPathCoveredByManifest', () => {
   it('returns false for empty manifest', () => {
     expect(isPathCoveredByManifest('anything.md', [])).toBe(false);
   });
+
+  it('returns false for ignored exact path', () => {
+    expect(
+      isPathCoveredByManifest('docs/cache.json', ['docs/'], ['docs/cache.json']),
+    ).toBe(false);
+  });
+
+  it('returns false for file inside ignored directory', () => {
+    expect(
+      isPathCoveredByManifest('docs/cache/data.bin', ['docs/'], ['docs/cache/']),
+    ).toBe(false);
+  });
+
+  it('returns true for non-ignored file in tracked directory', () => {
+    expect(
+      isPathCoveredByManifest('docs/readme.md', ['docs/'], ['docs/cache/']),
+    ).toBe(true);
+  });
+
+  it('ignore has no effect on untracked paths', () => {
+    expect(
+      isPathCoveredByManifest('src/main.ts', ['docs/'], ['src/main.ts']),
+    ).toBe(false);
+  });
 });