shadow-git 1.0.3 → 1.1.1

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

@@ -46,25 +46,25 @@ describe('track verify', () => {
       expect(result.valid).toBe(true);
     });
 
-    it('blocks stale .gitignore-sgit.bat when no guard is active', async () => {
+    it('blocks stale .gitignore.sgit-parked 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
+      // Create a stale .gitignore.sgit-parked
       await writeFile(
-        join(tempDir, 'docs', '.gitignore-sgit.bat'),
+        join(tempDir, 'docs', '.gitignore.sgit-parked'),
         'stale\n',
       );
 
       const result = await verifyMain(tempDir);
       expect(result.valid).toBe(false);
       expect(
-        result.violations.some((v) => v.includes('.gitignore-sgit.bat')),
+        result.violations.some((v) => v.includes('.gitignore.sgit-parked')),
       ).toBe(true);
     });
 
-    it('skips stale .gitignore-sgit.bat check when guard is active', async () => {
+    it('skips stale .gitignore.sgit-parked check when guard is active', async () => {
       await mkdir(join(tempDir, 'docs'), { recursive: true });
       await writeFile(join(tempDir, 'docs', 'file.md'), 'content');
       await trackAdd(['docs']);
@@ -74,13 +74,13 @@ describe('track verify', () => {
         String(process.pid),
       );
       await writeFile(
-        join(tempDir, 'docs', '.gitignore-sgit.bat'),
+        join(tempDir, 'docs', '.gitignore.sgit-parked'),
         'managed by guard\n',
       );
 
       const result = await verifyMain(tempDir);
       expect(
-        result.violations.some((v) => v.includes('.gitignore-sgit.bat')),
+        result.violations.some((v) => v.includes('.gitignore.sgit-parked')),
       ).toBe(false);
 
       unlinkSync(join(tempDir, '.sgit', '.gitignore-guard'));
@@ -147,43 +147,43 @@ describe('track verify', () => {
       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 () => {
+    it('blocks stale .gitignore.sgit-parked 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
+      // Create a stale .gitignore.sgit-parked
       await writeFile(
-        join(tempDir, 'docs', '.gitignore-sgit.bat'),
+        join(tempDir, 'docs', '.gitignore.sgit-parked'),
         'stale\n',
       );
 
       const result = await verifyShadow(tempDir);
       expect(result.valid).toBe(false);
       expect(
-        result.violations.some((v) => v.includes('.gitignore-sgit.bat')),
+        result.violations.some((v) => v.includes('.gitignore.sgit-parked')),
       ).toBe(true);
     });
 
-    it('skips stale .gitignore-sgit.bat check when guard is active', async () => {
+    it('skips stale .gitignore.sgit-parked 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
+      // Simulate active guard: create lock with current PID + stale .gitignore.sgit-parked
       writeFileSync(
         join(tempDir, '.sgit', '.gitignore-guard'),
         String(process.pid),
       );
       await writeFile(
-        join(tempDir, 'docs', '.gitignore-sgit.bat'),
+        join(tempDir, 'docs', '.gitignore.sgit-parked'),
         'managed by guard\n',
       );
 
       const result = await verifyShadow(tempDir);
-      // Should not report .bat files as violations when guard is active
+      // Should not report stale files as violations when guard is active
       expect(
-        result.violations.some((v) => v.includes('.gitignore-sgit.bat')),
+        result.violations.some((v) => v.includes('.gitignore.sgit-parked')),
       ).toBe(false);
 
       // Cleanup

package/tests/core/exclude.test.ts

@@ -50,17 +50,17 @@ describe('generateMainExclude', () => {
     expect(result).toContain('notes/todo.md\n');
   });
 
-  it('includes .gitignore-sgit.bat in managed block', () => {
+  it('includes .gitignore.sgit-parked in managed block', () => {
     const result = generateMainExclude('', ['notes.md']);
-    expect(result).toContain('.gitignore-sgit.bat\n');
+    expect(result).toContain('.gitignore.sgit-parked\n');
   });
 
-  it('orders entries: .sgit, .sgit.json, .gitignore-sgit.bat, then manifest paths', () => {
+  it('orders entries: .sgit, .sgit.json, .gitignore.sgit-parked, 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 batLine = lines.indexOf('.gitignore.sgit-parked');
     const zLine = lines.indexOf('z.txt');
     const aLine = lines.indexOf('a.txt');
     expect(sgitLine).toBeLessThan(sgitJsonLine);
@@ -158,19 +158,19 @@ describe('generateShadowExclude', () => {
     expect(lines).not.toContain('!./');
   });
 
-  it('re-ignores .gitignore-sgit.bat after allow-list', () => {
+  it('re-ignores .gitignore.sgit-parked after allow-list', () => {
     const result = generateShadowExclude(['docs/']);
     const lines = result.split('\n');
     const allowLine = lines.indexOf('!docs/**');
-    const batLine = lines.indexOf('.gitignore-sgit.bat');
+    const batLine = lines.indexOf('.gitignore.sgit-parked');
     expect(batLine).toBeGreaterThan(-1);
     expect(batLine).toBeGreaterThan(allowLine);
   });
 
-  it('includes .gitignore-sgit.bat even for empty manifest', () => {
+  it('includes .gitignore.sgit-parked even for empty manifest', () => {
     const result = generateShadowExclude([]);
     const lines = result.split('\n');
-    expect(lines).toContain('.gitignore-sgit.bat');
+    expect(lines).toContain('.gitignore.sgit-parked');
   });
 
   it('has no per-path comment lines', () => {
@@ -186,12 +186,12 @@ describe('generateShadowExclude', () => {
     expect(lines).toContain('temp2/cache/');
   });
 
-  it('places ignore rules after un-ignore and before .gitignore-sgit.bat', () => {
+  it('places ignore rules after un-ignore and before .gitignore.sgit-parked', () => {
     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');
+    const batLine = lines.indexOf('.gitignore.sgit-parked');
     expect(ignoreLine).toBeGreaterThan(unignoreLine);
     expect(ignoreLine).toBeLessThan(batLine);
   });

package/tests/core/gitignore.test.ts

@@ -57,11 +57,11 @@ describe('gitignore manipulator', () => {
   // disableGitignores
   // ---------------------------------------------------------------
   describe('disableGitignores', () => {
-    it('renames .gitignore to .gitignore-sgit.bat in tracked directory', () => {
+    it('renames .gitignore to .gitignore.sgit-parked 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(
+      expect(fileExists(join(tempDir, 'secret', '.gitignore.sgit-parked'))).toBe(
         true,
       );
     });
@@ -139,9 +139,9 @@ describe('gitignore manipulator', () => {
       expect(disabled).toEqual([]);
     });
 
-    it('throws StaleGitignoreError when .gitignore-sgit.bat already exists', async () => {
+    it('throws StaleGitignoreError when .gitignore.sgit-parked already exists', async () => {
       await writeFile(
-        join(tempDir, 'secret', '.gitignore-sgit.bat'),
+        join(tempDir, 'secret', '.gitignore.sgit-parked'),
         'stale\n',
       );
       expect(() => disableGitignores(tempDir, ['secret/'])).toThrow(
@@ -212,12 +212,12 @@ describe('gitignore manipulator', () => {
   // enableGitignores
   // ---------------------------------------------------------------
   describe('enableGitignores', () => {
-    it('renames .gitignore-sgit.bat back to .gitignore', () => {
+    it('renames .gitignore.sgit-parked 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(
+      expect(fileExists(join(tempDir, 'secret', '.gitignore.sgit-parked'))).toBe(
         false,
       );
     });
@@ -255,28 +255,28 @@ describe('gitignore manipulator', () => {
   // findStaleGitignores
   // ---------------------------------------------------------------
   describe('findStaleGitignores', () => {
-    it('finds .gitignore-sgit.bat in tracked dirs', async () => {
+    it('finds .gitignore.sgit-parked in tracked dirs', async () => {
       await writeFile(
-        join(tempDir, 'secret', '.gitignore-sgit.bat'),
+        join(tempDir, 'secret', '.gitignore.sgit-parked'),
         'stale\n',
       );
       const stale = findStaleGitignores(tempDir, ['secret/']);
-      expect(stale).toEqual(['secret/.gitignore-sgit.bat']);
+      expect(stale).toEqual(['secret/.gitignore.sgit-parked']);
     });
 
-    it('finds .gitignore-sgit.bat in ancestor dirs for file entries', async () => {
+    it('finds .gitignore.sgit-parked in ancestor dirs for file entries', async () => {
       await writeFile(
-        join(tempDir, 'secret', '.gitignore-sgit.bat'),
+        join(tempDir, 'secret', '.gitignore.sgit-parked'),
         'stale\n',
       );
       const stale = findStaleGitignores(tempDir, ['secret/data.txt']);
-      expect(stale).toContain('secret/.gitignore-sgit.bat');
+      expect(stale).toContain('secret/.gitignore.sgit-parked');
     });
 
-    it('finds .gitignore-sgit.bat at root', async () => {
-      await writeFile(join(tempDir, '.gitignore-sgit.bat'), 'stale\n');
+    it('finds .gitignore.sgit-parked at root', async () => {
+      await writeFile(join(tempDir, '.gitignore.sgit-parked'), 'stale\n');
       const stale = findStaleGitignores(tempDir, ['secret/']);
-      expect(stale).toContain('.gitignore-sgit.bat');
+      expect(stale).toContain('.gitignore.sgit-parked');
     });
 
     it('returns empty when no stale files exist', () => {
@@ -314,7 +314,7 @@ describe('gitignore manipulator', () => {
     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(
+      expect(fileExists(join(tempDir, 'secret', '.gitignore.sgit-parked'))).toBe(
         true,
       );
       expect(fileExists(join(tempDir, '.sgit', '.gitignore-guard'))).toBe(true);
@@ -322,7 +322,7 @@ describe('gitignore manipulator', () => {
       cleanup();
 
       expect(fileExists(join(tempDir, 'secret', '.gitignore'))).toBe(true);
-      expect(fileExists(join(tempDir, 'secret', '.gitignore-sgit.bat'))).toBe(
+      expect(fileExists(join(tempDir, 'secret', '.gitignore.sgit-parked'))).toBe(
         false,
       );
       expect(fileExists(join(tempDir, '.sgit', '.gitignore-guard'))).toBe(
@@ -365,10 +365,10 @@ describe('gitignore manipulator', () => {
       unlinkSync(lockPath);
     });
 
-    it('auto-cleans stale .bat files from a crashed process', () => {
+    it('auto-cleans stale .gitignore.sgit-parked files from a crashed process', () => {
       renameSync(
         join(tempDir, 'secret', '.gitignore'),
-        join(tempDir, 'secret', '.gitignore-sgit.bat'),
+        join(tempDir, 'secret', '.gitignore.sgit-parked'),
       );
       writeFileSync(
         join(tempDir, '.sgit', '.gitignore-guard'),
@@ -376,8 +376,8 @@ describe('gitignore manipulator', () => {
       );
 
       const cleanup = setupGitignoreGuard(tempDir, ['secret/']);
-      // Guard should have restored stale .bat, then re-disabled
-      expect(fileExists(join(tempDir, 'secret', '.gitignore-sgit.bat'))).toBe(
+      // Guard should have restored stale .gitignore.sgit-parked, then re-disabled
+      expect(fileExists(join(tempDir, 'secret', '.gitignore.sgit-parked'))).toBe(
         true,
       );
       cleanup();
@@ -401,7 +401,7 @@ describe('gitignore manipulator', () => {
         cleanup();
       }
       expect(fileExists(join(tempDir, 'secret', '.gitignore'))).toBe(true);
-      expect(fileExists(join(tempDir, 'secret', '.gitignore-sgit.bat'))).toBe(
+      expect(fileExists(join(tempDir, 'secret', '.gitignore.sgit-parked'))).toBe(
         false,
       );
     });
@@ -458,9 +458,9 @@ describe('gitignore manipulator', () => {
   });
 
   // ---------------------------------------------------------------
-  // .gitignore-sgit.bat must never persist
+  // .gitignore.sgit-parked must never persist
   // ---------------------------------------------------------------
-  describe('.gitignore-sgit.bat must not exist after any sgit command', () => {
+  describe('.gitignore.sgit-parked must not exist after any sgit command', () => {
     it('does not exist after successful guard lifecycle', () => {
       const cleanup = setupGitignoreGuard(tempDir, ['secret/']);
       cleanup();
@@ -479,23 +479,23 @@ describe('gitignore manipulator', () => {
       expect(findStaleGitignores(tempDir, ['secret/'])).toEqual([]);
     });
 
-    it('disableGitignores throws when .gitignore-sgit.bat already exists', async () => {
+    it('disableGitignores throws when .gitignore.sgit-parked already exists', async () => {
       await writeFile(
-        join(tempDir, 'secret', '.gitignore-sgit.bat'),
+        join(tempDir, 'secret', '.gitignore.sgit-parked'),
         'stale content\n',
       );
       expect(() => disableGitignores(tempDir, ['secret/'])).toThrow(
         StaleGitignoreError,
       );
       expect(() => disableGitignores(tempDir, ['secret/'])).toThrow(
-        /stale .gitignore-sgit.bat/,
+        /stale .gitignore.sgit-parked/,
       );
     });
 
     it('guard auto-recovers stale files then proceeds normally', () => {
       renameSync(
         join(tempDir, 'secret', '.gitignore'),
-        join(tempDir, 'secret', '.gitignore-sgit.bat'),
+        join(tempDir, 'secret', '.gitignore.sgit-parked'),
       );
       writeFileSync(
         join(tempDir, '.sgit', '.gitignore-guard'),
@@ -506,7 +506,7 @@ describe('gitignore manipulator', () => {
       cleanup();
 
       expect(fileExists(join(tempDir, 'secret', '.gitignore'))).toBe(true);
-      expect(fileExists(join(tempDir, 'secret', '.gitignore-sgit.bat'))).toBe(
+      expect(fileExists(join(tempDir, 'secret', '.gitignore.sgit-parked'))).toBe(
         false,
       );
       expect(findStaleGitignores(tempDir, ['secret/'])).toEqual([]);
@@ -518,7 +518,7 @@ describe('gitignore manipulator', () => {
 
 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, 'secret', '.gitignore.sgit-parked'))).toBe(false);
   expect(fileExists(join(root, '.sgit', '.gitignore-guard'))).toBe(false);
 }