shadow-git 0.1.0

package/tests/core/hooks.test.ts

@@ -0,0 +1,222 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import {
+  readFile,
+  writeFile,
+  mkdir,
+  access,
+  symlink,
+  readdir,
+} from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { join } from 'node:path';
+import {
+  installMainHook,
+  installShadowHook,
+  uninstallMainHook,
+  getHookDir,
+} from '../../src/core/hooks';
+import { createTempGitRepo, removeTempDir } from '../helpers';
+
+describe('getHookDir', () => {
+  let root: string;
+
+  beforeEach(async () => {
+    root = await createTempGitRepo();
+  });
+
+  afterEach(async () => {
+    await removeTempDir(root);
+  });
+
+  it('returns .git/hooks by default', async () => {
+    expect(await getHookDir(root)).toBe(join(root, '.git', 'hooks'));
+  });
+
+  it('returns custom hooksPath when configured', async () => {
+    const { execFile } = await import('node:child_process');
+    const { promisify } = await import('node:util');
+    const exec = promisify(execFile);
+    await exec('git', ['-C', root, 'config', 'core.hooksPath', '.githooks']);
+    expect(await getHookDir(root)).toBe(join(root, '.githooks'));
+  });
+});
+
+describe('installMainHook', () => {
+  let root: string;
+
+  beforeEach(async () => {
+    root = await createTempGitRepo();
+  });
+
+  afterEach(async () => {
+    await removeTempDir(root);
+  });
+
+  it('creates runner and sgit hook when no hook exists', async () => {
+    await installMainHook(root);
+
+    const hookDir = join(root, '.git', 'hooks');
+    const runner = await readFile(join(hookDir, 'pre-commit'), 'utf-8');
+    expect(runner).toContain('pre-commit.d');
+    expect(runner).toContain('#!/bin/sh');
+
+    const sgitHook = await readFile(
+      join(hookDir, 'pre-commit.d', 'sgit'),
+      'utf-8',
+    );
+    expect(sgitHook).toContain('sgit track verify --main');
+
+    // Verify executable
+    await access(join(hookDir, 'pre-commit'), constants.X_OK);
+    await access(join(hookDir, 'pre-commit.d', 'sgit'), constants.X_OK);
+  });
+
+  it('preserves existing regular file hook', async () => {
+    const hookDir = join(root, '.git', 'hooks');
+    await mkdir(hookDir, { recursive: true });
+    await writeFile(join(hookDir, 'pre-commit'), '#!/bin/sh\necho original', {
+      mode: 0o755,
+    });
+
+    await installMainHook(root);
+
+    const original = await readFile(
+      join(hookDir, 'pre-commit.d', 'original'),
+      'utf-8',
+    );
+    expect(original).toContain('echo original');
+
+    const runner = await readFile(join(hookDir, 'pre-commit'), 'utf-8');
+    expect(runner).toContain('pre-commit.d');
+  });
+
+  it('handles existing symlink hook', async () => {
+    const hookDir = join(root, '.git', 'hooks');
+    await mkdir(hookDir, { recursive: true });
+
+    // Create target file elsewhere
+    const target = join(root, 'my-hook.sh');
+    await writeFile(target, '#!/bin/sh\necho symlink-target', { mode: 0o755 });
+    await symlink(target, join(hookDir, 'pre-commit'));
+
+    await installMainHook(root);
+
+    const original = await readFile(
+      join(hookDir, 'pre-commit.d', 'original'),
+      'utf-8',
+    );
+    expect(original).toContain('echo symlink-target');
+
+    const runner = await readFile(join(hookDir, 'pre-commit'), 'utf-8');
+    expect(runner).toContain('pre-commit.d');
+  });
+
+  it('only adds sgit hook if pre-commit.d already exists', async () => {
+    const hookDir = join(root, '.git', 'hooks');
+    const dDir = join(hookDir, 'pre-commit.d');
+    await mkdir(dDir, { recursive: true });
+    await writeFile(join(dDir, 'lint'), '#!/bin/sh\necho lint', {
+      mode: 0o755,
+    });
+
+    await installMainHook(root);
+
+    // lint hook still there
+    const lint = await readFile(join(dDir, 'lint'), 'utf-8');
+    expect(lint).toContain('echo lint');
+
+    // sgit hook added
+    const sgit = await readFile(join(dDir, 'sgit'), 'utf-8');
+    expect(sgit).toContain('sgit track verify --main');
+  });
+});
+
+describe('installShadowHook', () => {
+  let root: string;
+
+  beforeEach(async () => {
+    root = await createTempGitRepo();
+  });
+
+  afterEach(async () => {
+    await removeTempDir(root);
+  });
+
+  it('creates shadow pre-commit hook', async () => {
+    const sgitDir = join(root, '.sgit');
+    await mkdir(sgitDir, { recursive: true });
+
+    await installShadowHook(sgitDir);
+
+    const hook = await readFile(join(sgitDir, 'hooks', 'pre-commit'), 'utf-8');
+    expect(hook).toContain('sgit track verify --shadow');
+    await access(join(sgitDir, 'hooks', 'pre-commit'), constants.X_OK);
+  });
+});
+
+describe('uninstallMainHook', () => {
+  let root: string;
+
+  beforeEach(async () => {
+    root = await createTempGitRepo();
+  });
+
+  afterEach(async () => {
+    await removeTempDir(root);
+  });
+
+  it('restores original hook when present', async () => {
+    const hookDir = join(root, '.git', 'hooks');
+    await mkdir(hookDir, { recursive: true });
+    await writeFile(join(hookDir, 'pre-commit'), '#!/bin/sh\necho original', {
+      mode: 0o755,
+    });
+    await installMainHook(root);
+
+    await uninstallMainHook(root);
+
+    const restored = await readFile(join(hookDir, 'pre-commit'), 'utf-8');
+    expect(restored).toContain('echo original');
+    // pre-commit.d should be gone
+    await expect(
+      access(join(hookDir, 'pre-commit.d'), constants.F_OK),
+    ).rejects.toThrow();
+  });
+
+  it('removes runner when pre-commit.d is empty', async () => {
+    await installMainHook(root);
+    await uninstallMainHook(root);
+
+    const hookDir = join(root, '.git', 'hooks');
+    await expect(
+      access(join(hookDir, 'pre-commit'), constants.F_OK),
+    ).rejects.toThrow();
+    await expect(
+      access(join(hookDir, 'pre-commit.d'), constants.F_OK),
+    ).rejects.toThrow();
+  });
+
+  it('leaves runner when other hooks exist in pre-commit.d', async () => {
+    const hookDir = join(root, '.git', 'hooks');
+    await installMainHook(root);
+
+    // Add another hook to pre-commit.d
+    await writeFile(
+      join(hookDir, 'pre-commit.d', 'lint'),
+      '#!/bin/sh\necho lint',
+      { mode: 0o755 },
+    );
+
+    await uninstallMainHook(root);
+
+    // Runner and lint should remain
+    const runner = await readFile(join(hookDir, 'pre-commit'), 'utf-8');
+    expect(runner).toContain('pre-commit.d');
+    const lint = await readFile(join(hookDir, 'pre-commit.d', 'lint'), 'utf-8');
+    expect(lint).toContain('echo lint');
+    // sgit hook should be gone
+    await expect(
+      access(join(hookDir, 'pre-commit.d', 'sgit'), constants.F_OK),
+    ).rejects.toThrow();
+  });
+});

package/tests/core/manifest.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import {
+  readManifest,
+  writeManifest,
+  addPath,
+  removePath,
+} from '../../src/core/manifest';
+import { createTempGitRepo, removeTempDir } from '../helpers';
+
+describe('manifest', () => {
+  let root: string;
+
+  beforeEach(async () => {
+    root = await createTempGitRepo();
+  });
+
+  afterEach(async () => {
+    await removeTempDir(root);
+  });
+
+  describe('readManifest', () => {
+    it('reads a valid manifest', async () => {
+      await writeFile(
+        join(root, '.sgit.json'),
+        JSON.stringify({ paths: ['docs/'] }, null, 2),
+      );
+      const manifest = await readManifest(root);
+      expect(manifest.paths).toEqual(['docs/']);
+    });
+
+    it('throws if manifest does not exist', async () => {
+      await expect(readManifest(root)).rejects.toThrow();
+    });
+  });
+
+  describe('writeManifest', () => {
+    it('writes formatted JSON with trailing newline', async () => {
+      await writeManifest(root, { paths: ['a.txt', 'b/'] });
+      const raw = await readFile(join(root, '.sgit.json'), 'utf-8');
+      expect(raw).toBe(
+        JSON.stringify({ paths: ['a.txt', 'b/'] }, null, 2) + '\n',
+      );
+    });
+
+    it('preserves unknown keys', async () => {
+      await writeFile(
+        join(root, '.sgit.json'),
+        JSON.stringify(
+          { paths: ['a.txt'], remotes: { origin: 'url' } },
+          null,
+          2,
+        ),
+      );
+      const manifest = await readManifest(root);
+      manifest.paths.push('b.txt');
+      await writeManifest(root, manifest);
+      const result = JSON.parse(
+        await readFile(join(root, '.sgit.json'), 'utf-8'),
+      );
+      expect(result.remotes).toEqual({ origin: 'url' });
+      expect(result.paths).toEqual(['a.txt', 'b.txt']);
+    });
+  });
+
+  describe('addPath', () => {
+    it('adds a new path', async () => {
+      await writeManifest(root, { paths: [] });
+      const added = await addPath(root, 'notes/todo.md');
+      expect(added).toBe(true);
+      const manifest = await readManifest(root);
+      expect(manifest.paths).toEqual(['notes/todo.md']);
+    });
+
+    it('returns false for duplicate', async () => {
+      await writeManifest(root, { paths: ['notes/todo.md'] });
+      const added = await addPath(root, 'notes/todo.md');
+      expect(added).toBe(false);
+    });
+  });
+
+  describe('removePath', () => {
+    it('removes an existing path', async () => {
+      await writeManifest(root, { paths: ['a.txt', 'b.txt'] });
+      const removed = await removePath(root, 'a.txt');
+      expect(removed).toBe(true);
+      const manifest = await readManifest(root);
+      expect(manifest.paths).toEqual(['b.txt']);
+    });
+
+    it('returns false for non-existent path', async () => {
+      await writeManifest(root, { paths: ['a.txt'] });
+      const removed = await removePath(root, 'missing.txt');
+      expect(removed).toBe(false);
+    });
+  });
+});

package/tests/core/paths.test.ts

@@ -0,0 +1,113 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import {
+  normalizePath,
+  isPathCoveredByManifest,
+} from '../../src/core/paths';
+import { createTempGitRepo, removeTempDir } from '../helpers';
+
+describe('normalizePath', () => {
+  let root: string;
+  let originalCwd: string;
+
+  beforeEach(async () => {
+    originalCwd = process.cwd();
+    root = await createTempGitRepo();
+    process.chdir(root);
+  });
+
+  afterEach(async () => {
+    process.chdir(originalCwd);
+    await removeTempDir(root);
+  });
+
+  it('normalizes a simple file path', async () => {
+    await writeFile(join(root, 'notes.md'), 'hello');
+    expect(await normalizePath('notes.md', root)).toBe('notes.md');
+  });
+
+  it('strips ./ prefix', async () => {
+    await writeFile(join(root, 'notes.md'), 'hello');
+    expect(await normalizePath('./notes.md', root)).toBe('notes.md');
+  });
+
+  it('resolves .. components', async () => {
+    await mkdir(join(root, 'a'));
+    await writeFile(join(root, 'notes.md'), 'hello');
+    expect(await normalizePath('a/../notes.md', root)).toBe('notes.md');
+  });
+
+  it('collapses double slashes', async () => {
+    await mkdir(join(root, 'docs'), { recursive: true });
+    await writeFile(join(root, 'docs', 'file.md'), 'hello');
+    expect(await normalizePath('docs//file.md', root)).toBe('docs/file.md');
+  });
+
+  it('adds trailing slash for directories', async () => {
+    await mkdir(join(root, 'docs', '.internal'), { recursive: true });
+    expect(await normalizePath('docs/.internal', root)).toBe(
+      'docs/.internal/',
+    );
+  });
+
+  it('keeps trailing slash for directory input', async () => {
+    await mkdir(join(root, 'docs'), { recursive: true });
+    expect(await normalizePath('docs/', root)).toBe('docs/');
+  });
+
+  it('rejects paths outside root', async () => {
+    await expect(normalizePath('../../etc/passwd', root)).rejects.toThrow(
+      'outside the project root',
+    );
+  });
+
+  it('resolves relative to root from subdirectory path', async () => {
+    await mkdir(join(root, 'sub'));
+    await writeFile(join(root, 'sub', 'file.txt'), 'hello');
+    // Calling with a path relative to root
+    expect(await normalizePath('sub/file.txt', root)).toBe('sub/file.txt');
+  });
+});
+
+describe('isPathCoveredByManifest', () => {
+  it('matches exact file path', () => {
+    expect(
+      isPathCoveredByManifest('notes/todo.md', ['notes/todo.md']),
+    ).toBe(true);
+  });
+
+  it('matches file inside tracked directory', () => {
+    expect(
+      isPathCoveredByManifest('docs/.internal/design.md', [
+        'docs/.internal/',
+      ]),
+    ).toBe(true);
+  });
+
+  it('matches nested file inside tracked directory', () => {
+    expect(
+      isPathCoveredByManifest('docs/.internal/sub/deep.md', [
+        'docs/.internal/',
+      ]),
+    ).toBe(true);
+  });
+
+  it('does not match unrelated path', () => {
+    expect(
+      isPathCoveredByManifest('src/main.ts', ['docs/.internal/']),
+    ).toBe(false);
+  });
+
+  it('does not match partial directory name', () => {
+    expect(
+      isPathCoveredByManifest('docs/.internal-extra/file.md', [
+        'docs/.internal/',
+      ]),
+    ).toBe(false);
+  });
+
+  it('returns false for empty manifest', () => {
+    expect(isPathCoveredByManifest('anything.md', [])).toBe(false);
+  });
+});

package/tests/core/repository.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { findRoot, validateShadowRepo } from '../../src/core/repository';
+import { createTempGitRepo, removeTempDir } from '../helpers';
+
+describe('findRoot', () => {
+  let tempDir: string;
+  const originalCwd = process.cwd();
+
+  beforeEach(async () => {
+    tempDir = await createTempGitRepo();
+    process.chdir(tempDir);
+  });
+
+  afterEach(async () => {
+    process.chdir(originalCwd);
+    await removeTempDir(tempDir);
+  });
+
+  it('returns the git root directory', async () => {
+    expect(await findRoot()).toBe(tempDir);
+  });
+
+  it('works from a subdirectory', async () => {
+    const subdir = join(tempDir, 'subdir');
+    await mkdir(subdir);
+    process.chdir(subdir);
+    expect(await findRoot()).toBe(tempDir);
+  });
+
+  it('throws outside a git repo', async () => {
+    const { mkdtemp, realpath, rm } = await import('node:fs/promises');
+    const { tmpdir } = await import('node:os');
+    const raw = await mkdtemp(join(tmpdir(), 'sgit-test-nogit-'));
+    const nonGitDir = await realpath(raw);
+    process.chdir(nonGitDir);
+    await expect(findRoot()).rejects.toThrow();
+    process.chdir(tempDir);
+    await rm(nonGitDir, { recursive: true });
+  });
+});
+
+describe('validateShadowRepo', () => {
+  let tempDir: string;
+  const originalCwd = process.cwd();
+
+  beforeEach(async () => {
+    tempDir = await createTempGitRepo();
+    process.chdir(tempDir);
+  });
+
+  afterEach(async () => {
+    process.chdir(originalCwd);
+    await removeTempDir(tempDir);
+  });
+
+  it('throws when .sgit does not exist', async () => {
+    await expect(validateShadowRepo(tempDir)).rejects.toThrow(
+      'not a shadow git repository',
+    );
+  });
+
+  it('passes when .sgit exists', async () => {
+    await mkdir(join(tempDir, '.sgit'));
+    await expect(validateShadowRepo(tempDir)).resolves.toBeUndefined();
+  });
+});

package/tests/helpers.ts

@@ -0,0 +1,21 @@
+import { mkdtemp, rm, realpath } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+export async function createTempGitRepo(): Promise<string> {
+  const raw = await mkdtemp(join(tmpdir(), 'sgit-test-'));
+  const dir = await realpath(raw);
+  await execFileAsync('git', ['init'], { cwd: dir });
+  await execFileAsync('git', ['-C', dir, 'config', 'user.email', 'test@test.com']);
+  await execFileAsync('git', ['-C', dir, 'config', 'user.name', 'Test']);
+  await execFileAsync('git', ['commit', '--allow-empty', '-m', 'initial'], { cwd: dir });
+  return dir;
+}
+
+export async function removeTempDir(dir: string): Promise<void> {
+  await rm(dir, { recursive: true, force: true });
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "sourceMap": true,
+    "types": ["node"]
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsup.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/cli.ts'],
+  format: ['esm'],
+  target: 'node18',
+  clean: true,
+  banner: {
+    js: '#!/usr/bin/env node',
+  },
+});

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    pool: 'forks',
+    testTimeout: 10000,
+  },
+});