shadow-git 0.1.0

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

@@ -0,0 +1,146 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import {
+  readFile,
+  mkdir,
+  writeFile,
+  access,
+  symlink,
+} from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { join } from 'node:path';
+import { trackInit } from '../../../src/commands/track/init';
+import { execGit } from '../../../src/core/git';
+import { createTempGitRepo, removeTempDir } from '../../helpers';
+
+describe('track init', () => {
+  let tempDir: string;
+  const originalCwd = process.cwd();
+
+  beforeEach(async () => {
+    tempDir = await createTempGitRepo();
+    process.chdir(tempDir);
+  });
+
+  afterEach(async () => {
+    process.chdir(originalCwd);
+    await removeTempDir(tempDir);
+  });
+
+  it('initializes shadow repository', async () => {
+    await trackInit();
+
+    // .sgit directory exists
+    await access(join(tempDir, '.sgit'), constants.F_OK);
+
+    // Config values
+    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 exists with empty paths
+    const manifest = JSON.parse(
+      await readFile(join(tempDir, '.sgit.json'), 'utf-8'),
+    );
+    expect(manifest).toEqual({ paths: [] });
+
+    // .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');
+
+    // .sgit/info/exclude has base pattern
+    const shadowExclude = await readFile(
+      join(tempDir, '.sgit', 'info', 'exclude'),
+      'utf-8',
+    );
+    expect(shadowExclude).toContain('*');
+    expect(shadowExclude).toContain('!.sgit.json');
+
+    // Hooks installed
+    const mainHook = await readFile(
+      join(tempDir, '.git', 'hooks', 'pre-commit.d', 'sgit'),
+      'utf-8',
+    );
+    expect(mainHook).toContain('sgit track verify --main');
+
+    const shadowHook = await readFile(
+      join(tempDir, '.sgit', 'hooks', 'pre-commit'),
+      'utf-8',
+    );
+    expect(shadowHook).toContain('sgit track verify --shadow');
+
+    // Initial commit with .sgit.json
+    const log = await execGit(['log', '--oneline'], {
+      gitDir: join(tempDir, '.sgit'),
+      workTree: tempDir,
+    });
+    expect(log).toContain('sgit: initialize shadow repository');
+
+    const files = await execGit(['ls-files'], {
+      gitDir: join(tempDir, '.sgit'),
+      workTree: tempDir,
+    });
+    expect(files).toContain('.sgit.json');
+  });
+
+  it('errors if already initialized', async () => {
+    await trackInit();
+    await expect(trackInit()).rejects.toThrow('already initialized');
+  });
+
+  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);
+
+    await expect(trackInit()).rejects.toThrow();
+
+    process.chdir(tempDir);
+    await rm(nonGit, { recursive: true });
+  });
+
+  it('preserves existing pre-commit hook', async () => {
+    const hookDir = join(tempDir, '.git', 'hooks');
+    await mkdir(hookDir, { recursive: true });
+    await writeFile(join(hookDir, 'pre-commit'), '#!/bin/sh\necho original', {
+      mode: 0o755,
+    });
+
+    await trackInit();
+
+    const original = await readFile(
+      join(hookDir, 'pre-commit.d', 'original'),
+      'utf-8',
+    );
+    expect(original).toContain('echo original');
+  });
+
+  it('preserves existing .git/info/exclude entries', async () => {
+    await mkdir(join(tempDir, '.git', 'info'), { recursive: true });
+    await writeFile(
+      join(tempDir, '.git', 'info', 'exclude'),
+      '*.log\nbuild/\n',
+    );
+
+    await trackInit();
+
+    const exclude = await readFile(
+      join(tempDir, '.git', 'info', 'exclude'),
+      'utf-8',
+    );
+    expect(exclude).toContain('*.log');
+    expect(exclude).toContain('build/');
+    expect(exclude).toContain('# sgit\n.sgit\n');
+  });
+});

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

@@ -0,0 +1,107 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { readFile, writeFile, mkdir, access } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { join } from 'node:path';
+import { trackInit } from '../../../src/commands/track/init';
+import { trackAdd } from '../../../src/commands/track/add';
+import { trackRemove } from '../../../src/commands/track/remove';
+import { trackList } from '../../../src/commands/track/list';
+import { readManifest } from '../../../src/core/manifest';
+import { execGit } from '../../../src/core/git';
+import { createTempGitRepo, removeTempDir } from '../../helpers';
+
+describe('track remove', () => {
+  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 a tracked file', async () => {
+    await writeFile(join(tempDir, 'notes.md'), 'hello');
+    await trackAdd(['notes.md']);
+    await execGit(['commit', '-m', 'add notes'], {
+      gitDir: join(tempDir, '.sgit'),
+      workTree: tempDir,
+    });
+
+    await trackRemove(['notes.md']);
+
+    // Removed from manifest
+    const manifest = await readManifest(tempDir);
+    expect(manifest.paths).not.toContain('notes.md');
+
+    // File still on disk
+    await access(join(tempDir, 'notes.md'), constants.F_OK);
+
+    // No longer in shadow exclude
+    const mainExclude = await readFile(
+      join(tempDir, '.git', 'info', 'exclude'),
+      'utf-8',
+    );
+    expect(mainExclude).not.toContain('# sgit\nnotes.md\n');
+  });
+
+  it('removes a tracked directory', async () => {
+    await mkdir(join(tempDir, 'docs', '.internal'), { recursive: true });
+    await writeFile(
+      join(tempDir, 'docs', '.internal', 'design.md'),
+      'notes',
+    );
+    await trackAdd(['docs/.internal']);
+    await execGit(['commit', '-m', 'add docs'], {
+      gitDir: join(tempDir, '.sgit'),
+      workTree: tempDir,
+    });
+
+    await trackRemove(['docs/.internal/']);
+
+    const manifest = await readManifest(tempDir);
+    expect(manifest.paths).not.toContain('docs/.internal/');
+  });
+
+  it('errors for untracked path', async () => {
+    await expect(trackRemove(['not-tracked.md'])).rejects.toThrow(
+      'not tracked by sgit',
+    );
+  });
+});
+
+describe('track list', () => {
+  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('returns tracked paths', async () => {
+    await writeFile(join(tempDir, 'a.txt'), 'a');
+    await writeFile(join(tempDir, 'b.txt'), 'b');
+    await trackAdd(['a.txt', 'b.txt']);
+
+    const paths = await trackList();
+    expect(paths).toContain('a.txt');
+    expect(paths).toContain('b.txt');
+  });
+
+  it('returns empty array when no paths', async () => {
+    const paths = await trackList();
+    expect(paths).toEqual([]);
+  });
+});

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

@@ -0,0 +1,118 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { trackInit } from '../../../src/commands/track/init';
+import { trackSync } from '../../../src/commands/track/sync';
+import { readManifest, writeManifest } from '../../../src/core/manifest';
+import { createTempGitRepo, removeTempDir } from '../../helpers';
+
+describe('track sync', () => {
+  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('regenerates exclude files from manifest', async () => {
+    // Add a path to manifest manually
+    await mkdir(join(tempDir, 'notes'), { recursive: true });
+    await writeFile(join(tempDir, 'notes', 'todo.md'), 'hello');
+    const manifest = await readManifest(tempDir);
+    manifest.paths.push('notes/todo.md');
+    await writeManifest(tempDir, manifest);
+
+    // Clear exclude files
+    await writeFile(join(tempDir, '.git', 'info', 'exclude'), '');
+    await writeFile(join(tempDir, '.sgit', 'info', 'exclude'), '');
+
+    await trackSync();
+
+    // Verify .git/info/exclude
+    const mainExclude = await readFile(
+      join(tempDir, '.git', 'info', 'exclude'),
+      'utf-8',
+    );
+    expect(mainExclude).toContain('# sgit\n.sgit\n');
+    expect(mainExclude).toContain('# sgit\nnotes/todo.md\n');
+
+    // Verify .sgit/info/exclude
+    const shadowExclude = await readFile(
+      join(tempDir, '.sgit', 'info', 'exclude'),
+      'utf-8',
+    );
+    expect(shadowExclude).toContain('*');
+    expect(shadowExclude).toContain('!.sgit.json');
+    expect(shadowExclude).toContain('!notes/');
+    expect(shadowExclude).toContain('notes/*');
+    expect(shadowExclude).toContain('!notes/todo.md');
+  });
+
+  it('preserves non-sgit entries in .git/info/exclude', async () => {
+    // Add user entry then corrupt sgit entries
+    await writeFile(
+      join(tempDir, '.git', 'info', 'exclude'),
+      '*.log\nbuild/\n# sgit\ngarbage\n',
+    );
+
+    await trackSync();
+
+    const mainExclude = await readFile(
+      join(tempDir, '.git', 'info', 'exclude'),
+      'utf-8',
+    );
+    expect(mainExclude).toContain('*.log');
+    expect(mainExclude).toContain('build/');
+    expect(mainExclude).not.toContain('garbage');
+    expect(mainExclude).toContain('# sgit\n.sgit\n');
+  });
+
+  it('warns for missing manifest paths', async () => {
+    // Add a path to manifest that does not exist on disk
+    const manifest = await readManifest(tempDir);
+    manifest.paths.push('nonexistent/file.md');
+    await writeManifest(tempDir, manifest);
+
+    // Capture stderr to check for warning
+    const stderrWrite = process.stderr.write;
+    let stderrOutput = '';
+    process.stderr.write = ((chunk: any) => {
+      stderrOutput += chunk.toString();
+      return true;
+    }) as any;
+
+    await trackSync();
+
+    process.stderr.write = stderrWrite;
+    expect(stderrOutput).toContain('path does not exist: nonexistent/file.md');
+  });
+
+  it('handles deeply nested paths', async () => {
+    await mkdir(join(tempDir, 'a', 'b', 'c'), { recursive: true });
+    await writeFile(join(tempDir, 'a', 'b', 'c', 'file.txt'), 'deep');
+    const manifest = await readManifest(tempDir);
+    manifest.paths.push('a/b/c/file.txt');
+    await writeManifest(tempDir, manifest);
+
+    await trackSync();
+
+    const shadowExclude = await readFile(
+      join(tempDir, '.sgit', 'info', 'exclude'),
+      'utf-8',
+    );
+    expect(shadowExclude).toContain('!a/');
+    expect(shadowExclude).toContain('a/*');
+    expect(shadowExclude).toContain('!a/b/');
+    expect(shadowExclude).toContain('a/b/*');
+    expect(shadowExclude).toContain('!a/b/c/');
+    expect(shadowExclude).toContain('a/b/c/*');
+    expect(shadowExclude).toContain('!a/b/c/file.txt');
+  });
+});

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

@@ -0,0 +1,96 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { trackInit } from '../../../src/commands/track/init';
+import { trackAdd } from '../../../src/commands/track/add';
+import { verifyMain, verifyShadow } from '../../../src/commands/track/verify';
+import { execGit } from '../../../src/core/git';
+import { createTempGitRepo, removeTempDir } from '../../helpers';
+
+describe('track verify', () => {
+  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);
+  });
+
+  describe('--main', () => {
+    it('blocks commit of shadow-tracked file in main repo', async () => {
+      await mkdir(join(tempDir, 'notes'), { recursive: true });
+      await writeFile(join(tempDir, 'notes', 'todo.md'), 'hello');
+      await trackAdd(['notes/todo.md']);
+
+      // Force-stage in main git (bypassing exclude)
+      await execGit(['add', '-f', 'notes/todo.md'], { cwd: tempDir });
+
+      const result = await verifyMain(tempDir);
+      expect(result.valid).toBe(false);
+      expect(result.violations).toContain('notes/todo.md');
+    });
+
+    it('allows commit of non-shadow file in main repo', async () => {
+      await writeFile(join(tempDir, 'readme.md'), 'hello');
+      await execGit(['add', 'readme.md'], { cwd: tempDir });
+
+      const result = await verifyMain(tempDir);
+      expect(result.valid).toBe(true);
+    });
+
+    it('blocks file inside shadow-tracked directory', async () => {
+      await mkdir(join(tempDir, 'docs', '.internal'), { recursive: true });
+      await writeFile(
+        join(tempDir, 'docs', '.internal', 'design.md'),
+        'notes',
+      );
+      await trackAdd(['docs/.internal']);
+
+      await execGit(['add', '-f', 'docs/.internal/design.md'], {
+        cwd: tempDir,
+      });
+
+      const result = await verifyMain(tempDir);
+      expect(result.valid).toBe(false);
+      expect(result.violations).toContain('docs/.internal/design.md');
+    });
+  });
+
+  describe('--shadow', () => {
+    it('blocks commit of non-manifest file in shadow repo', async () => {
+      await mkdir(join(tempDir, 'src'), { recursive: true });
+      await writeFile(join(tempDir, 'src', 'main.ts'), 'code');
+
+      // Force-stage in shadow repo
+      await execGit(['add', '-f', 'src/main.ts'], {
+        gitDir: join(tempDir, '.sgit'),
+        workTree: tempDir,
+      });
+
+      const result = await verifyShadow(tempDir);
+      expect(result.valid).toBe(false);
+      expect(result.violations).toContain('src/main.ts');
+    });
+
+    it('allows .sgit.json in shadow repo', async () => {
+      // .sgit.json is always allowed
+      const result = await verifyShadow(tempDir);
+      // The init already committed .sgit.json, check with no new staged files
+      expect(result.valid).toBe(true);
+    });
+
+    it('allows manifest-tracked file in shadow repo', async () => {
+      await writeFile(join(tempDir, 'notes.md'), 'hello');
+      await trackAdd(['notes.md']);
+
+      const result = await verifyShadow(tempDir);
+      expect(result.valid).toBe(true);
+    });
+  });
+});

package/tests/core/exclude.test.ts

@@ -0,0 +1,120 @@
+import { describe, it, expect } from 'vitest';
+import {
+  generateMainExclude,
+  generateShadowExclude,
+} 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');
+  });
+
+  it('preserves existing non-sgit lines', () => {
+    const existing = '*.log\nbuild/\n';
+    const result = generateMainExclude(existing, []);
+    expect(result).toContain('*.log');
+    expect(result).toContain('build/');
+    expect(result).toContain('# sgit\n.sgit\n');
+  });
+
+  it('replaces old sgit entries', () => {
+    const existing = 'user-entry\n# sgit\nold-path\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');
+  });
+
+  it('includes manifest paths with sgit marker', () => {
+    const result = generateMainExclude('', [
+      'docs/.internal/',
+      'notes/todo.md',
+    ]);
+    expect(result).toContain('# sgit\ndocs/.internal/\n');
+    expect(result).toContain('# sgit\nnotes/todo.md\n');
+  });
+
+  it('orders entries: .sgit, .sgit.json, 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 zLine = lines.indexOf('z.txt');
+    const aLine = lines.indexOf('a.txt');
+    expect(sgitLine).toBeLessThan(sgitJsonLine);
+    expect(sgitJsonLine).toBeLessThan(zLine);
+    expect(sgitJsonLine).toBeLessThan(aLine);
+  });
+});
+
+describe('generateShadowExclude', () => {
+  it('generates base pattern for empty manifest', () => {
+    const result = generateShadowExclude([]);
+    expect(result).toContain('# Exclude everything by default');
+    expect(result).toContain('*');
+    expect(result).toContain('# .sgit.json (always tracked)');
+    expect(result).toContain('!.sgit.json');
+  });
+
+  it('generates ancestor chain for single file', () => {
+    const result = generateShadowExclude(['notes/todo.md']);
+    const lines = result.split('\n');
+    expect(lines).toContain('!notes/');
+    expect(lines).toContain('notes/*');
+    expect(lines).toContain('!notes/todo.md');
+  });
+
+  it('generates ancestor chain for directory', () => {
+    const result = generateShadowExclude(['docs/.internal/']);
+    const lines = result.split('\n');
+    expect(lines).toContain('!docs/');
+    expect(lines).toContain('docs/*');
+    expect(lines).toContain('!docs/.internal/');
+  });
+
+  it('generates deep ancestor chain', () => {
+    const result = generateShadowExclude(['a/b/c/file.txt']);
+    const lines = result.split('\n');
+    expect(lines).toContain('!a/');
+    expect(lines).toContain('a/*');
+    expect(lines).toContain('!a/b/');
+    expect(lines).toContain('a/b/*');
+    expect(lines).toContain('!a/b/c/');
+    expect(lines).toContain('a/b/c/*');
+    expect(lines).toContain('!a/b/c/file.txt');
+  });
+
+  it('deduplicates shared ancestors', () => {
+    const result = generateShadowExclude([
+      'docs/.internal/',
+      '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/*');
+    expect(lines).toContain('!docs/.drafts/notes.md');
+  });
+
+  it('handles root-level file (no ancestors)', () => {
+    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', () => {
+    const result = generateShadowExclude(['notes/todo.md']);
+    expect(result).toContain('# notes/todo.md');
+  });
+});