shadow-git 0.1.0 → 1.0.2

package/tests/commands/track/unignore.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { readFile, mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { trackInit } from '../../../src/commands/track/init';
+import { trackAdd } from '../../../src/commands/track/add';
+import { trackIgnore } from '../../../src/commands/track/ignore';
+import { trackUnignore } from '../../../src/commands/track/unignore';
+import { createTempGitRepo, removeTempDir } from '../../helpers';
+
+describe('track unignore', () => {
+  let tempDir: string;
+  const originalCwd = process.cwd();
+
+  beforeEach(async () => {
+    tempDir = await createTempGitRepo();
+    process.chdir(tempDir);
+    await trackInit();
+  });
+
+  afterEach(async () => {
+    process.chdir(originalCwd);
+    await removeTempDir(tempDir);
+  });
+
+  it('removes path from ignore list and syncs excludes', async () => {
+    await mkdir(join(tempDir, 'docs', 'cache'), { recursive: true });
+    await writeFile(join(tempDir, 'docs', 'readme.md'), 'hello');
+    await writeFile(join(tempDir, 'docs', 'cache', 'data.bin'), 'cached');
+    await trackAdd(['docs/']);
+    await trackIgnore(['docs/cache/']);
+
+    await trackUnignore(['docs/cache/']);
+
+    const manifest = JSON.parse(
+      await readFile(join(tempDir, '.sgit.json'), 'utf-8'),
+    );
+    expect(manifest.ignore).not.toContain('docs/cache/');
+
+    // Shadow exclude should no longer have the re-ignore
+    const shadowExclude = await readFile(
+      join(tempDir, '.sgit', 'info', 'exclude'),
+      'utf-8',
+    );
+    expect(shadowExclude).not.toContain('docs/cache/');
+  });
+
+  it('errors if path is not in ignore list', async () => {
+    await mkdir(join(tempDir, 'docs'), { recursive: true });
+    await writeFile(join(tempDir, 'docs', 'readme.md'), 'hello');
+    await trackAdd(['docs/']);
+
+    await expect(trackUnignore(['docs/readme.md'])).rejects.toThrow(
+      'not in the ignore list',
+    );
+  });
+
+  it('handles trailing slash matching', async () => {
+    await mkdir(join(tempDir, 'docs', 'cache'), { recursive: true });
+    await writeFile(join(tempDir, 'docs', 'readme.md'), 'hello');
+    await writeFile(join(tempDir, 'docs', 'cache', 'data.bin'), 'cached');
+    await trackAdd(['docs/']);
+    await trackIgnore(['docs/cache/']);
+
+    // Unignore without trailing slash should still match
+    await trackUnignore(['docs/cache']);
+
+    const manifest = JSON.parse(
+      await readFile(join(tempDir, '.sgit.json'), 'utf-8'),
+    );
+    expect(manifest.ignore).not.toContain('docs/cache/');
+  });
+});

package/tests/commands/track/verify.test.ts

@@ -1,9 +1,11 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { writeFile, mkdir } from 'node:fs/promises';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
+import { writeFileSync, unlinkSync } from 'node:fs';
 import { trackInit } from '../../../src/commands/track/init';
 import { trackAdd } from '../../../src/commands/track/add';
 import { verifyMain, verifyShadow } from '../../../src/commands/track/verify';
+import { readManifest, writeManifest } from '../../../src/core/manifest';
 import { execGit } from '../../../src/core/git';
 import { createTempGitRepo, removeTempDir } from '../../helpers';
 
@@ -44,6 +46,46 @@ describe('track verify', () => {
       expect(result.valid).toBe(true);
     });
 
+    it('blocks stale .gitignore-sgit.bat when no guard is active', async () => {
+      await mkdir(join(tempDir, 'docs'), { recursive: true });
+      await writeFile(join(tempDir, 'docs', 'file.md'), 'content');
+      await trackAdd(['docs']);
+
+      // Create a stale .gitignore-sgit.bat
+      await writeFile(
+        join(tempDir, 'docs', '.gitignore-sgit.bat'),
+        'stale\n',
+      );
+
+      const result = await verifyMain(tempDir);
+      expect(result.valid).toBe(false);
+      expect(
+        result.violations.some((v) => v.includes('.gitignore-sgit.bat')),
+      ).toBe(true);
+    });
+
+    it('skips stale .gitignore-sgit.bat check when guard is active', async () => {
+      await mkdir(join(tempDir, 'docs'), { recursive: true });
+      await writeFile(join(tempDir, 'docs', 'file.md'), 'content');
+      await trackAdd(['docs']);
+
+      writeFileSync(
+        join(tempDir, '.sgit', '.gitignore-guard'),
+        String(process.pid),
+      );
+      await writeFile(
+        join(tempDir, 'docs', '.gitignore-sgit.bat'),
+        'managed by guard\n',
+      );
+
+      const result = await verifyMain(tempDir);
+      expect(
+        result.violations.some((v) => v.includes('.gitignore-sgit.bat')),
+      ).toBe(false);
+
+      unlinkSync(join(tempDir, '.sgit', '.gitignore-guard'));
+    });
+
     it('blocks file inside shadow-tracked directory', async () => {
       await mkdir(join(tempDir, 'docs', '.internal'), { recursive: true });
       await writeFile(
@@ -92,5 +134,94 @@ describe('track verify', () => {
       const result = await verifyShadow(tempDir);
       expect(result.valid).toBe(true);
     });
+
+    it('blocks deletion of .sgit.json', async () => {
+      // Stage .sgit.json for deletion in shadow repo
+      await execGit(['rm', '--cached', '.sgit.json'], {
+        gitDir: join(tempDir, '.sgit'),
+        workTree: tempDir,
+      });
+
+      const result = await verifyShadow(tempDir);
+      expect(result.valid).toBe(false);
+      expect(result.violations.some((v) => v.includes('.sgit.json') && v.includes('cannot delete'))).toBe(true);
+    });
+
+    it('blocks stale .gitignore-sgit.bat when no guard is active', async () => {
+      await mkdir(join(tempDir, 'docs'), { recursive: true });
+      await writeFile(join(tempDir, 'docs', 'file.md'), 'content');
+      await trackAdd(['docs']);
+
+      // Create a stale .gitignore-sgit.bat
+      await writeFile(
+        join(tempDir, 'docs', '.gitignore-sgit.bat'),
+        'stale\n',
+      );
+
+      const result = await verifyShadow(tempDir);
+      expect(result.valid).toBe(false);
+      expect(
+        result.violations.some((v) => v.includes('.gitignore-sgit.bat')),
+      ).toBe(true);
+    });
+
+    it('skips stale .gitignore-sgit.bat check when guard is active', async () => {
+      await mkdir(join(tempDir, 'docs'), { recursive: true });
+      await writeFile(join(tempDir, 'docs', 'file.md'), 'content');
+      await trackAdd(['docs']);
+
+      // Simulate active guard: create lock with current PID + stale .bat
+      writeFileSync(
+        join(tempDir, '.sgit', '.gitignore-guard'),
+        String(process.pid),
+      );
+      await writeFile(
+        join(tempDir, 'docs', '.gitignore-sgit.bat'),
+        'managed by guard\n',
+      );
+
+      const result = await verifyShadow(tempDir);
+      // Should not report .bat files as violations when guard is active
+      expect(
+        result.violations.some((v) => v.includes('.gitignore-sgit.bat')),
+      ).toBe(false);
+
+      // Cleanup
+      unlinkSync(join(tempDir, '.sgit', '.gitignore-guard'));
+    });
+
+    it('blocks invalid .sgit.json modifications', async () => {
+      const sgitJsonPath = join(tempDir, '.sgit.json');
+      const original = await readFile(sgitJsonPath, 'utf-8');
+
+      // Stage invalid JSON, then restore on disk so readManifest works
+      await writeFile(sgitJsonPath, 'not json{{{');
+      await execGit(['add', '-f', '.sgit.json'], {
+        gitDir: join(tempDir, '.sgit'),
+        workTree: tempDir,
+      });
+      await writeFile(sgitJsonPath, original);
+
+      const result = await verifyShadow(tempDir);
+      expect(result.valid).toBe(false);
+      expect(result.violations.some((v) => v.includes('invalid JSON'))).toBe(true);
+    });
+
+    it('blocks .sgit.json missing paths array', async () => {
+      const sgitJsonPath = join(tempDir, '.sgit.json');
+      const original = await readFile(sgitJsonPath, 'utf-8');
+
+      // Stage JSON without paths, then restore on disk
+      await writeFile(sgitJsonPath, '{"version": 1}');
+      await execGit(['add', '-f', '.sgit.json'], {
+        gitDir: join(tempDir, '.sgit'),
+        workTree: tempDir,
+      });
+      await writeFile(sgitJsonPath, original);
+
+      const result = await verifyShadow(tempDir);
+      expect(result.valid).toBe(false);
+      expect(result.violations.some((v) => v.includes('missing "paths" array'))).toBe(true);
+    });
   });
 });

package/tests/core/exclude.test.ts

@@ -2,14 +2,17 @@ import { describe, it, expect } from 'vitest';
 import {
   generateMainExclude,
   generateShadowExclude,
+  SGIT_BLOCK_START,
+  SGIT_BLOCK_END,
 } from '../../src/core/exclude';
 
 describe('generateMainExclude', () => {
   it('adds sgit entries to empty file', () => {
     const result = generateMainExclude('', []);
-    expect(result).toContain('# sgit-managed (do not edit below this line)');
-    expect(result).toContain('# sgit\n.sgit\n');
-    expect(result).toContain('# sgit\n.sgit.json\n');
+    expect(result).toContain(SGIT_BLOCK_START);
+    expect(result).toContain(SGIT_BLOCK_END);
+    expect(result).toContain('.sgit\n');
+    expect(result).toContain('.sgit.json\n');
   });
 
   it('preserves existing non-sgit lines', () => {
@@ -17,45 +20,74 @@ describe('generateMainExclude', () => {
     const result = generateMainExclude(existing, []);
     expect(result).toContain('*.log');
     expect(result).toContain('build/');
-    expect(result).toContain('# sgit\n.sgit\n');
+    expect(result).toContain('.sgit\n');
   });
 
   it('replaces old sgit entries', () => {
-    const existing = 'user-entry\n# sgit\nold-path\n';
+    const existing = `user-entry\n${SGIT_BLOCK_START}\nold-path\n${SGIT_BLOCK_END}\n`;
     const result = generateMainExclude(existing, ['new-path.md']);
     expect(result).toContain('user-entry');
     expect(result).not.toContain('old-path');
-    expect(result).toContain('# sgit\nnew-path.md\n');
+    expect(result).toContain('new-path.md\n');
   });
 
-  it('includes manifest paths with sgit marker', () => {
+  it('strips legacy format on regeneration', () => {
+    const existing = 'user-entry\n# sgit\nold-path\n# sgit-managed (do not edit below this line)\n# sgit\nold2\n';
+    const result = generateMainExclude(existing, ['new.md']);
+    expect(result).toContain('user-entry');
+    expect(result).not.toContain('old-path');
+    expect(result).not.toContain('old2');
+    expect(result).toContain('new.md');
+    expect(result).not.toContain('# sgit\n');
+  });
+
+  it('includes manifest paths', () => {
     const result = generateMainExclude('', [
       'docs/.internal/',
       'notes/todo.md',
     ]);
-    expect(result).toContain('# sgit\ndocs/.internal/\n');
-    expect(result).toContain('# sgit\nnotes/todo.md\n');
+    expect(result).toContain('docs/.internal/\n');
+    expect(result).toContain('notes/todo.md\n');
   });
 
-  it('orders entries: .sgit, .sgit.json, then manifest paths', () => {
+  it('includes .gitignore-sgit.bat in managed block', () => {
+    const result = generateMainExclude('', ['notes.md']);
+    expect(result).toContain('.gitignore-sgit.bat\n');
+  });
+
+  it('orders entries: .sgit, .sgit.json, .gitignore-sgit.bat, then manifest paths', () => {
     const result = generateMainExclude('', ['z.txt', 'a.txt']);
     const lines = result.split('\n');
     const sgitLine = lines.indexOf('.sgit');
     const sgitJsonLine = lines.indexOf('.sgit.json');
+    const batLine = lines.indexOf('.gitignore-sgit.bat');
     const zLine = lines.indexOf('z.txt');
     const aLine = lines.indexOf('a.txt');
     expect(sgitLine).toBeLessThan(sgitJsonLine);
-    expect(sgitJsonLine).toBeLessThan(zLine);
-    expect(sgitJsonLine).toBeLessThan(aLine);
+    expect(sgitJsonLine).toBeLessThan(batLine);
+    expect(batLine).toBeLessThan(zLine);
+    expect(batLine).toBeLessThan(aLine);
+  });
+
+  it('has no per-line markers or extra comments inside block', () => {
+    const result = generateMainExclude('', ['notes.md']);
+    const lines = result.split('\n');
+    const startIdx = lines.indexOf(SGIT_BLOCK_START);
+    const endIdx = lines.indexOf(SGIT_BLOCK_END);
+    const blockLines = lines.slice(startIdx + 1, endIdx);
+    // Every line inside should be a plain entry, no comments
+    for (const line of blockLines) {
+      expect(line).not.toMatch(/^#/);
+    }
   });
 });
 
 describe('generateShadowExclude', () => {
   it('generates base pattern for empty manifest', () => {
     const result = generateShadowExclude([]);
-    expect(result).toContain('# Exclude everything by default');
+    expect(result).toContain(SGIT_BLOCK_START);
+    expect(result).toContain(SGIT_BLOCK_END);
     expect(result).toContain('*');
-    expect(result).toContain('# .sgit.json (always tracked)');
     expect(result).toContain('!.sgit.json');
   });
 
@@ -73,6 +105,22 @@ describe('generateShadowExclude', () => {
     expect(lines).toContain('!docs/');
     expect(lines).toContain('docs/*');
     expect(lines).toContain('!docs/.internal/');
+    expect(lines).toContain('!docs/.internal/**');
+  });
+
+  it('generates recursive pattern for root-level directory', () => {
+    const result = generateShadowExclude(['docs/']);
+    const lines = result.split('\n');
+    expect(lines).toContain('!docs/');
+    expect(lines).toContain('!docs/**');
+  });
+
+  it('does not generate recursive pattern for file entries', () => {
+    const result = generateShadowExclude(['notes/todo.md']);
+    const lines = result.split('\n');
+    expect(lines).toContain('!notes/todo.md');
+    expect(lines).not.toContain('!notes/todo.md**');
+    expect(lines).not.toContain('!notes/todo.md/**');
   });
 
   it('generates deep ancestor chain', () => {
@@ -93,12 +141,10 @@ describe('generateShadowExclude', () => {
       'docs/.drafts/notes.md',
     ]);
     const lines = result.split('\n');
-    // !docs/ and docs/* should appear only once
     const docsUnignore = lines.filter((l) => l === '!docs/');
     const docsReignore = lines.filter((l) => l === 'docs/*');
     expect(docsUnignore).toHaveLength(1);
     expect(docsReignore).toHaveLength(1);
-    // Both targets should be present
     expect(lines).toContain('!docs/.internal/');
     expect(lines).toContain('!docs/.drafts/');
     expect(lines).toContain('docs/.drafts/*');
@@ -109,12 +155,54 @@ describe('generateShadowExclude', () => {
     const result = generateShadowExclude(['readme.md']);
     const lines = result.split('\n');
     expect(lines).toContain('!readme.md');
-    // No ancestor chain needed for root-level files
     expect(lines).not.toContain('!./');
   });
 
-  it('includes comment before each tracked path section', () => {
+  it('re-ignores .gitignore-sgit.bat after allow-list', () => {
+    const result = generateShadowExclude(['docs/']);
+    const lines = result.split('\n');
+    const allowLine = lines.indexOf('!docs/**');
+    const batLine = lines.indexOf('.gitignore-sgit.bat');
+    expect(batLine).toBeGreaterThan(-1);
+    expect(batLine).toBeGreaterThan(allowLine);
+  });
+
+  it('includes .gitignore-sgit.bat even for empty manifest', () => {
+    const result = generateShadowExclude([]);
+    const lines = result.split('\n');
+    expect(lines).toContain('.gitignore-sgit.bat');
+  });
+
+  it('has no per-path comment lines', () => {
     const result = generateShadowExclude(['notes/todo.md']);
-    expect(result).toContain('# notes/todo.md');
+    expect(result).not.toContain('# notes/todo.md');
+  });
+
+  it('adds ignore paths as re-ignore rules', () => {
+    const result = generateShadowExclude(['temp2/'], ['temp2/cache/']);
+    const lines = result.split('\n');
+    expect(lines).toContain('!temp2/');
+    expect(lines).toContain('!temp2/**');
+    expect(lines).toContain('temp2/cache/');
+  });
+
+  it('places ignore rules after un-ignore and before .gitignore-sgit.bat', () => {
+    const result = generateShadowExclude(['docs/'], ['docs/cache/']);
+    const lines = result.split('\n');
+    const unignoreLine = lines.indexOf('!docs/**');
+    const ignoreLine = lines.indexOf('docs/cache/');
+    const batLine = lines.indexOf('.gitignore-sgit.bat');
+    expect(ignoreLine).toBeGreaterThan(unignoreLine);
+    expect(ignoreLine).toBeLessThan(batLine);
+  });
+
+  it('handles multiple ignore paths', () => {
+    const result = generateShadowExclude(
+      ['temp2/'],
+      ['temp2/cache/', 'temp2/logs/'],
+    );
+    const lines = result.split('\n');
+    expect(lines).toContain('temp2/cache/');
+    expect(lines).toContain('temp2/logs/');
   });
 });