shadow-git 0.1.0 → 1.0.3

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

@@ -0,0 +1,315 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import {
+  readFile,
+  writeFile,
+  mkdir,
+  access,
+  readdir,
+} from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { join } from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { trackInit } from '../../../src/commands/track/init';
+import { trackClone } from '../../../src/commands/track/clone';
+import { execGit } from '../../../src/core/git';
+import {
+  createTempGitRepo,
+  createBareRemoteRepo,
+  removeTempDir,
+} from '../../helpers';
+
+const execFileAsync = promisify(execFile);
+
+describe('track clone', () => {
+  let tempDir: string;
+  let remoteDir: string;
+  const originalCwd = process.cwd();
+
+  beforeEach(async () => {
+    tempDir = await createTempGitRepo();
+    process.chdir(tempDir);
+  });
+
+  afterEach(async () => {
+    process.chdir(originalCwd);
+    if (tempDir) await removeTempDir(tempDir);
+    if (remoteDir) await removeTempDir(remoteDir);
+  });
+
+  it('clones shadow repository with no conflicts', async () => {
+    remoteDir = await createBareRemoteRepo({
+      'CLAUDE.md': '# Claude config',
+      '.claude/settings.json': '{"key": "value"}',
+    });
+
+    await trackClone(remoteDir);
+
+    // .sgit directory exists
+    await access(join(tempDir, '.sgit'), constants.F_OK);
+
+    // Config correct
+    const bare = await execGit(['config', 'core.bare'], {
+      gitDir: join(tempDir, '.sgit'),
+    });
+    expect(bare).toBe('false');
+
+    const worktree = await execGit(['config', 'core.worktree'], {
+      gitDir: join(tempDir, '.sgit'),
+    });
+    expect(worktree).toBe(tempDir);
+
+    // .sgit.json on disk
+    const manifest = JSON.parse(
+      await readFile(join(tempDir, '.sgit.json'), 'utf-8'),
+    );
+    expect(manifest.paths).toContain('CLAUDE.md');
+    expect(manifest.paths).toContain('.claude/settings.json');
+
+    // Files checked out
+    expect(await readFile(join(tempDir, 'CLAUDE.md'), 'utf-8')).toBe(
+      '# Claude config',
+    );
+    expect(
+      await readFile(join(tempDir, '.claude', 'settings.json'), 'utf-8'),
+    ).toBe('{"key": "value"}');
+
+    // Exclude files correct
+    const mainExclude = await readFile(
+      join(tempDir, '.git', 'info', 'exclude'),
+      'utf-8',
+    );
+    expect(mainExclude).toContain('CLAUDE.md');
+    expect(mainExclude).toContain('.sgit\n');
+
+    const shadowExclude = await readFile(
+      join(tempDir, '.sgit', 'info', 'exclude'),
+      'utf-8',
+    );
+    expect(shadowExclude).toContain('!CLAUDE.md');
+
+    // Pre-commit hooks installed
+    const mainHook = await readFile(
+      join(tempDir, '.git', 'hooks', 'pre-commit.d', 'sgit'),
+      'utf-8',
+    );
+    expect(mainHook).toContain('sgit track verify --main');
+
+    const shadowPreCommit = await readFile(
+      join(tempDir, '.sgit', 'hooks', 'pre-commit'),
+      'utf-8',
+    );
+    expect(shadowPreCommit).toContain('sgit track verify --shadow');
+
+    // Sync hooks installed
+    const postMerge = await readFile(
+      join(tempDir, '.sgit', 'hooks', 'post-merge'),
+      'utf-8',
+    );
+    expect(postMerge).toContain('sgit track sync');
+
+    const postCheckout = await readFile(
+      join(tempDir, '.sgit', 'hooks', 'post-checkout'),
+      'utf-8',
+    );
+    expect(postCheckout).toContain('sgit track sync');
+  });
+
+  it('errors if shadow repo already exists', async () => {
+    remoteDir = await createBareRemoteRepo({ 'CLAUDE.md': 'content' });
+    await trackInit();
+
+    await expect(trackClone(remoteDir)).rejects.toThrow('already initialized');
+  });
+
+  it('errors when git identity is not configured', async () => {
+    remoteDir = await createBareRemoteRepo({ 'CLAUDE.md': 'content' });
+    await execFileAsync('git', ['-C', tempDir, 'config', '--unset', 'user.name']);
+    await expect(trackClone(remoteDir)).rejects.toThrow('git user identity not configured');
+  });
+
+  it('errors outside git repo', async () => {
+    const { mkdtemp, realpath, rm } = await import('node:fs/promises');
+    const { tmpdir } = await import('node:os');
+    const nonGitRaw = await mkdtemp(join(tmpdir(), 'sgit-test-nogit-'));
+    const nonGit = await realpath(nonGitRaw);
+    process.chdir(nonGit);
+    remoteDir = await createBareRemoteRepo({ 'CLAUDE.md': 'content' });
+
+    await expect(trackClone(remoteDir)).rejects.toThrow();
+
+    process.chdir(tempDir);
+    await rm(nonGit, { recursive: true });
+  });
+
+  it('resolves conflicts with option 1 (keep sgit)', async () => {
+    remoteDir = await createBareRemoteRepo({ 'CLAUDE.md': '# From sgit' });
+
+    // Create conflicting file
+    await writeFile(join(tempDir, 'CLAUDE.md'), '# Local version');
+
+    await trackClone(remoteDir, { onConflict: 1 });
+
+    // sgit version should win
+    expect(await readFile(join(tempDir, 'CLAUDE.md'), 'utf-8')).toBe(
+      '# From sgit',
+    );
+  });
+
+  it('resolves conflicts with option 2 (keep originals)', async () => {
+    remoteDir = await createBareRemoteRepo({ 'CLAUDE.md': '# From sgit' });
+
+    await writeFile(join(tempDir, 'CLAUDE.md'), '# Local version');
+
+    await trackClone(remoteDir, { onConflict: 2 });
+
+    // Local version kept
+    expect(await readFile(join(tempDir, 'CLAUDE.md'), 'utf-8')).toBe(
+      '# Local version',
+    );
+
+    // sgit status should show it as modified
+    const status = await execGit(['status', '--porcelain'], {
+      gitDir: join(tempDir, '.sgit'),
+      workTree: tempDir,
+    });
+    expect(status).toContain('CLAUDE.md');
+  });
+
+  it('resolves conflicts with option 3 (rename originals)', async () => {
+    remoteDir = await createBareRemoteRepo({ 'CLAUDE.md': '# From sgit' });
+
+    await writeFile(join(tempDir, 'CLAUDE.md'), '# Local version');
+
+    await trackClone(remoteDir, { onConflict: 3 });
+
+    // sgit version checked out
+    expect(await readFile(join(tempDir, 'CLAUDE.md'), 'utf-8')).toBe(
+      '# From sgit',
+    );
+
+    // Original renamed with suffix pattern
+    const files = await readdir(tempDir);
+    const renamed = files.find((f) =>
+      /^CLAUDE-original~[0-9a-f]{4}\.md$/.test(f),
+    );
+    expect(renamed).toBeDefined();
+    expect(await readFile(join(tempDir, renamed!), 'utf-8')).toBe(
+      '# Local version',
+    );
+  });
+
+  it('handles directory-level conflicts', async () => {
+    remoteDir = await createBareRemoteRepo({
+      '.claude/settings.json': '{"from": "sgit"}',
+    });
+
+    // Create conflicting file inside directory
+    await mkdir(join(tempDir, '.claude'), { recursive: true });
+    await writeFile(
+      join(tempDir, '.claude', 'settings.json'),
+      '{"from": "local"}',
+    );
+
+    await trackClone(remoteDir, { onConflict: 1 });
+
+    // sgit version should be present
+    expect(
+      await readFile(join(tempDir, '.claude', 'settings.json'), 'utf-8'),
+    ).toBe('{"from": "sgit"}');
+  });
+
+  it('generates correct rename suffix format', async () => {
+    remoteDir = await createBareRemoteRepo({
+      'file.txt': 'content',
+      'noext': 'content',
+      'path/to/deep.md': 'content',
+    });
+
+    await writeFile(join(tempDir, 'file.txt'), 'local');
+    await writeFile(join(tempDir, 'noext'), 'local');
+    await mkdir(join(tempDir, 'path', 'to'), { recursive: true });
+    await writeFile(join(tempDir, 'path', 'to', 'deep.md'), 'local');
+
+    await trackClone(remoteDir, { onConflict: 3 });
+
+    // Check suffix patterns
+    const rootFiles = await readdir(tempDir);
+    expect(
+      rootFiles.some((f) => /^file-original~[0-9a-f]{4}\.txt$/.test(f)),
+    ).toBe(true);
+    expect(
+      rootFiles.some((f) => /^noext-original~[0-9a-f]{4}$/.test(f)),
+    ).toBe(true);
+
+    const deepFiles = await readdir(join(tempDir, 'path', 'to'));
+    expect(
+      deepFiles.some((f) => /^deep-original~[0-9a-f]{4}\.md$/.test(f)),
+    ).toBe(true);
+  });
+
+  it('installs post-merge and post-checkout hooks', async () => {
+    remoteDir = await createBareRemoteRepo({ 'CLAUDE.md': 'content' });
+
+    await trackClone(remoteDir);
+
+    const postMerge = await readFile(
+      join(tempDir, '.sgit', 'hooks', 'post-merge'),
+      'utf-8',
+    );
+    expect(postMerge).toContain('#!/bin/sh');
+    expect(postMerge).toContain('sgit track sync');
+    await access(join(tempDir, '.sgit', 'hooks', 'post-merge'), constants.X_OK);
+
+    const postCheckout = await readFile(
+      join(tempDir, '.sgit', 'hooks', 'post-checkout'),
+      'utf-8',
+    );
+    expect(postCheckout).toContain('#!/bin/sh');
+    expect(postCheckout).toContain('sgit track sync');
+    await access(
+      join(tempDir, '.sgit', 'hooks', 'post-checkout'),
+      constants.X_OK,
+    );
+  });
+
+  it('handles clone with empty manifest', async () => {
+    remoteDir = await createBareRemoteRepo({});
+
+    await trackClone(remoteDir);
+
+    const manifest = JSON.parse(
+      await readFile(join(tempDir, '.sgit.json'), 'utf-8'),
+    );
+    expect(manifest.paths).toEqual([]);
+  });
+
+  it('preserves existing pre-commit hook', async () => {
+    remoteDir = await createBareRemoteRepo({ 'CLAUDE.md': 'content' });
+
+    const hookDir = join(tempDir, '.git', 'hooks');
+    await mkdir(hookDir, { recursive: true });
+    await writeFile(join(hookDir, 'pre-commit'), '#!/bin/sh\necho original', {
+      mode: 0o755,
+    });
+
+    await trackClone(remoteDir);
+
+    const original = await readFile(
+      join(hookDir, 'pre-commit.d', 'original'),
+      'utf-8',
+    );
+    expect(original).toContain('echo original');
+  });
+
+  it('has remote origin configured for push/pull', async () => {
+    remoteDir = await createBareRemoteRepo({ 'CLAUDE.md': 'content' });
+
+    await trackClone(remoteDir);
+
+    const remoteUrl = await execGit(['config', 'remote.origin.url'], {
+      gitDir: join(tempDir, '.sgit'),
+    });
+    expect(remoteUrl).toBe(remoteDir);
+  });
+});

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

@@ -16,7 +16,7 @@ describe('completion scripts', () => {
     expect(script).toContain('complete -F _sgit sgit');
     expect(script).toContain('_init_completion');
     expect(script).toContain('git --list-cmds=main,others');
-    expect(script).toContain('init add remove list sync verify destroy completion');
+    expect(script).toContain('init clone add remove list sync verify ignore unignore destroy completion');
     expect(script).toContain('--adopt');
     expect(script).toContain('sgit track list');
     expect(script).toContain('__git_wrap__git_main');

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

@@ -5,6 +5,7 @@ import { join } from 'node:path';
 import { trackInit } from '../../../src/commands/track/init';
 import { trackAdd } from '../../../src/commands/track/add';
 import { trackDestroy } from '../../../src/commands/track/destroy';
+import { execGit } from '../../../src/core/git';
 import { createTempGitRepo, removeTempDir } from '../../helpers';
 
 describe('track destroy', () => {
@@ -43,21 +44,86 @@ describe('track destroy', () => {
     await trackDestroy({ force: true });
 
     const after = await readFile(excludePath, 'utf-8');
-    expect(after).not.toContain('# sgit\n');
+    expect(after).not.toContain('# sgit-managed');
     expect(after).not.toContain('.sgit');
   });
 
-  it('keeps previously tracked files on disk', async () => {
+  it('deletes tracked files by default', async () => {
     await writeFile(join(tempDir, 'notes.md'), 'keep me');
     await trackAdd(['notes.md']);
+    await execGit(['commit', '-m', 'add notes'], {
+      gitDir: join(tempDir, '.sgit'),
+      workTree: tempDir,
+    });
 
     await trackDestroy({ force: true });
 
+    // File should be gone
+    await expect(
+      access(join(tempDir, 'notes.md'), constants.F_OK),
+    ).rejects.toThrow();
+  });
+
+  it('keeps tracked files with --keep-files', async () => {
+    await writeFile(join(tempDir, 'notes.md'), 'keep me');
+    await trackAdd(['notes.md']);
+    await execGit(['commit', '-m', 'add notes'], {
+      gitDir: join(tempDir, '.sgit'),
+      workTree: tempDir,
+    });
+
+    await trackDestroy({ force: true, keepFiles: true });
+
     // File remains
     const content = await readFile(join(tempDir, 'notes.md'), 'utf-8');
     expect(content).toBe('keep me');
   });
 
+  it('deletes files in nested directories', async () => {
+    await mkdir(join(tempDir, 'docs', 'internal'), { recursive: true });
+    await writeFile(join(tempDir, 'docs', 'internal', 'notes.md'), 'hello');
+    await trackAdd(['docs/']);
+    await execGit(['commit', '-m', 'add docs'], {
+      gitDir: join(tempDir, '.sgit'),
+      workTree: tempDir,
+    });
+
+    await trackDestroy({ force: true });
+
+    // File and directory should be gone
+    await expect(
+      access(join(tempDir, 'docs', 'internal', 'notes.md'), constants.F_OK),
+    ).rejects.toThrow();
+    await expect(
+      access(join(tempDir, 'docs'), constants.F_OK),
+    ).rejects.toThrow();
+  });
+
+  it('does not delete non-sgit files in parent directories', async () => {
+    await mkdir(join(tempDir, 'docs'), { recursive: true });
+    await writeFile(join(tempDir, 'docs', 'tracked.md'), 'sgit');
+    await writeFile(join(tempDir, 'docs', 'unrelated.txt'), 'keep');
+    await trackAdd(['docs/tracked.md']);
+    await execGit(['commit', '-m', 'add tracked'], {
+      gitDir: join(tempDir, '.sgit'),
+      workTree: tempDir,
+    });
+
+    await trackDestroy({ force: true });
+
+    // Tracked file gone
+    await expect(
+      access(join(tempDir, 'docs', 'tracked.md'), constants.F_OK),
+    ).rejects.toThrow();
+
+    // Non-sgit file remains
+    const content = await readFile(join(tempDir, 'docs', 'unrelated.txt'), 'utf-8');
+    expect(content).toBe('keep');
+
+    // Directory remains (not empty)
+    await access(join(tempDir, 'docs'), constants.F_OK);
+  });
+
   it('restores original pre-commit hook', async () => {
     // Reinit with a pre-existing hook
     process.chdir(originalCwd);

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

@@ -0,0 +1,109 @@
+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 { execGit } from '../../../src/core/git';
+import { createTempGitRepo, removeTempDir } from '../../helpers';
+
+describe('track ignore', () => {
+  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('adds path to 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/']);
+
+    const manifest = JSON.parse(
+      await readFile(join(tempDir, '.sgit.json'), 'utf-8'),
+    );
+    expect(manifest.ignore).toContain('docs/cache/');
+
+    // Shadow exclude should re-ignore the path
+    const shadowExclude = await readFile(
+      join(tempDir, '.sgit', 'info', 'exclude'),
+      'utf-8',
+    );
+    expect(shadowExclude).toContain('docs/cache/');
+  });
+
+  it('errors if path is not covered by tracked paths', async () => {
+    await mkdir(join(tempDir, 'untracked'));
+    await writeFile(join(tempDir, 'untracked', 'file.txt'), 'hello');
+
+    await expect(trackIgnore(['untracked/file.txt'])).rejects.toThrow(
+      'not tracked by sgit',
+    );
+  });
+
+  it('skips already-ignored paths', 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 trackIgnore(['docs/cache/']);
+
+    const manifest = JSON.parse(
+      await readFile(join(tempDir, '.sgit.json'), 'utf-8'),
+    );
+    const cacheEntries = manifest.ignore.filter(
+      (p: string) => p === 'docs/cache/',
+    );
+    expect(cacheEntries).toHaveLength(1);
+  });
+
+  it('untracks ignored file from shadow index', async () => {
+    await mkdir(join(tempDir, 'docs'), { recursive: true });
+    await writeFile(join(tempDir, 'docs', 'secret.md'), 'secret');
+    await writeFile(join(tempDir, 'docs', 'readme.md'), 'hello');
+    await trackAdd(['docs/']);
+
+    // File should be in shadow index
+    const sgitDir = join(tempDir, '.sgit');
+    await execGit(['add', '-f', 'docs/secret.md'], {
+      gitDir: sgitDir,
+      workTree: tempDir,
+    });
+
+    await trackIgnore(['docs/secret.md']);
+
+    // File should no longer be in shadow index
+    const files = await execGit(['ls-files'], {
+      gitDir: sgitDir,
+      workTree: tempDir,
+    });
+    expect(files).not.toContain('docs/secret.md');
+  });
+
+  it('handles directory ignores', async () => {
+    await mkdir(join(tempDir, 'docs', 'tmp', 'nested'), { recursive: true });
+    await writeFile(join(tempDir, 'docs', 'readme.md'), 'hello');
+    await writeFile(join(tempDir, 'docs', 'tmp', 'nested', 'file.txt'), 'tmp');
+    await trackAdd(['docs/']);
+
+    await trackIgnore(['docs/tmp/']);
+
+    const manifest = JSON.parse(
+      await readFile(join(tempDir, '.sgit.json'), 'utf-8'),
+    );
+    expect(manifest.ignore).toContain('docs/tmp/');
+  });
+});

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

@@ -8,10 +8,14 @@ import {
 } from 'node:fs/promises';
 import { constants } from 'node:fs';
 import { join } from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
 import { trackInit } from '../../../src/commands/track/init';
 import { execGit } from '../../../src/core/git';
 import { createTempGitRepo, removeTempDir } from '../../helpers';
 
+const execFileAsync = promisify(execFile);
+
 describe('track init', () => {
   let tempDir: string;
   const originalCwd = process.cwd();
@@ -47,15 +51,15 @@ describe('track init', () => {
     const manifest = JSON.parse(
       await readFile(join(tempDir, '.sgit.json'), 'utf-8'),
     );
-    expect(manifest).toEqual({ paths: [] });
+    expect(manifest).toEqual({ paths: [], ignore: [] });
 
     // .git/info/exclude has sgit entries
     const mainExclude = await readFile(
       join(tempDir, '.git', 'info', 'exclude'),
       'utf-8',
     );
-    expect(mainExclude).toContain('# sgit\n.sgit\n');
-    expect(mainExclude).toContain('# sgit\n.sgit.json\n');
+    expect(mainExclude).toContain('.sgit\n');
+    expect(mainExclude).toContain('.sgit.json\n');
 
     // .sgit/info/exclude has base pattern
     const shadowExclude = await readFile(
@@ -78,6 +82,19 @@ describe('track init', () => {
     );
     expect(shadowHook).toContain('sgit track verify --shadow');
 
+    // Sync hooks installed
+    const postMerge = await readFile(
+      join(tempDir, '.sgit', 'hooks', 'post-merge'),
+      'utf-8',
+    );
+    expect(postMerge).toContain('sgit track sync');
+
+    const postCheckout = await readFile(
+      join(tempDir, '.sgit', 'hooks', 'post-checkout'),
+      'utf-8',
+    );
+    expect(postCheckout).toContain('sgit track sync');
+
     // Initial commit with .sgit.json
     const log = await execGit(['log', '--oneline'], {
       gitDir: join(tempDir, '.sgit'),
@@ -110,6 +127,11 @@ describe('track init', () => {
     await rm(nonGit, { recursive: true });
   });
 
+  it('errors when git identity is not configured', async () => {
+    await execFileAsync('git', ['-C', tempDir, 'config', '--unset', 'user.name']);
+    await expect(trackInit()).rejects.toThrow('git user identity not configured');
+  });
+
   it('preserves existing pre-commit hook', async () => {
     const hookDir = join(tempDir, '.git', 'hooks');
     await mkdir(hookDir, { recursive: true });
@@ -141,6 +163,7 @@ describe('track init', () => {
     );
     expect(exclude).toContain('*.log');
     expect(exclude).toContain('build/');
-    expect(exclude).toContain('# sgit\n.sgit\n');
+    expect(exclude).toContain('# sgit-managed\n');
+    expect(exclude).toContain('.sgit\n');
   });
 });

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

@@ -47,7 +47,7 @@ describe('track remove', () => {
       join(tempDir, '.git', 'info', 'exclude'),
       'utf-8',
     );
-    expect(mainExclude).not.toContain('# sgit\nnotes.md\n');
+    expect(mainExclude).not.toContain('\nnotes.md\n');
   });
 
   it('removes a tracked directory', async () => {

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

@@ -40,8 +40,8 @@ describe('track sync', () => {
       join(tempDir, '.git', 'info', 'exclude'),
       'utf-8',
     );
-    expect(mainExclude).toContain('# sgit\n.sgit\n');
-    expect(mainExclude).toContain('# sgit\nnotes/todo.md\n');
+    expect(mainExclude).toContain('# sgit-managed\n');
+    expect(mainExclude).toContain('notes/todo.md\n');
 
     // Verify .sgit/info/exclude
     const shadowExclude = await readFile(
@@ -71,7 +71,7 @@ describe('track sync', () => {
     expect(mainExclude).toContain('*.log');
     expect(mainExclude).toContain('build/');
     expect(mainExclude).not.toContain('garbage');
-    expect(mainExclude).toContain('# sgit\n.sgit\n');
+    expect(mainExclude).toContain('# sgit-managed\n');
   });
 
   it('warns for missing manifest paths', async () => {