shadow-git 0.1.0

package/src/core/paths.ts

@@ -0,0 +1,58 @@
+import { resolve, relative, sep } from 'node:path';
+import { stat } from 'node:fs/promises';
+import { SgitError } from './errors.js';
+
+export async function normalizePath(
+  inputPath: string,
+  root: string,
+): Promise<string> {
+  const absolute = resolve(process.cwd(), inputPath);
+  let rel = relative(root, absolute);
+
+  // Reject paths outside root
+  if (rel.startsWith('..')) {
+    throw new SgitError(`path is outside the project root: ${inputPath}`);
+  }
+
+  // Normalize separators to forward slashes
+  rel = rel.split(sep).join('/');
+
+  // Check if directory and add trailing slash
+  try {
+    const st = await stat(absolute);
+    if (st.isDirectory() && !rel.endsWith('/')) {
+      rel += '/';
+    }
+  } catch {
+    // If stat fails and input had trailing slash, keep it
+    if (inputPath.endsWith('/') && !rel.endsWith('/')) {
+      rel += '/';
+    }
+  }
+
+  return rel;
+}
+
+export function isPathCoveredByManifest(
+  filePath: string,
+  manifestPaths: string[],
+): boolean {
+  const caseInsensitive = process.platform === 'darwin';
+  const normalize = caseInsensitive
+    ? (s: string) => s.toLowerCase()
+    : (s: string) => s;
+
+  const normalizedFile = normalize(filePath);
+
+  for (const mPath of manifestPaths) {
+    const normalizedManifest = normalize(mPath);
+    if (normalizedManifest === normalizedFile) return true;
+    if (
+      normalizedManifest.endsWith('/') &&
+      normalizedFile.startsWith(normalizedManifest)
+    ) {
+      return true;
+    }
+  }
+  return false;
+}

package/src/core/repository.ts

@@ -0,0 +1,39 @@
+import { access, lstat } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { execGit } from './git.js';
+import { NotGitRepoError, NotInitializedError, SgitError } from './errors.js';
+
+export async function findRoot(): Promise<string> {
+  try {
+    return await execGit(['rev-parse', '--show-toplevel']);
+  } catch {
+    throw new NotGitRepoError();
+  }
+}
+
+export async function validateShadowRepo(root: string): Promise<void> {
+  try {
+    await access(join(root, '.sgit'), constants.F_OK);
+  } catch {
+    throw new NotInitializedError();
+  }
+}
+
+export async function validateNotWorktree(root: string): Promise<void> {
+  const gitDir = await execGit(['rev-parse', '--git-dir'], { cwd: root });
+  const commonDir = await execGit(['rev-parse', '--git-common-dir'], { cwd: root });
+  const absGitDir = resolve(root, gitDir);
+  const absCommonDir = resolve(root, commonDir);
+  if (absGitDir !== absCommonDir) {
+    throw new SgitError('shadow git is not supported in linked worktrees');
+  }
+}
+
+export async function validateNotSubmodule(root: string): Promise<void> {
+  const gitPath = join(root, '.git');
+  const stats = await lstat(gitPath);
+  if (!stats.isDirectory()) {
+    throw new SgitError('shadow git is not supported inside git submodules');
+  }
+}

package/src/utils/logger.ts

@@ -0,0 +1,21 @@
+const RESET = '\x1b[0m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+const CYAN = '\x1b[36m';
+
+export function info(msg: string): void {
+  process.stdout.write(`${CYAN}${msg}${RESET}\n`);
+}
+
+export function success(msg: string): void {
+  process.stdout.write(`${GREEN}${msg}${RESET}\n`);
+}
+
+export function warn(msg: string): void {
+  process.stderr.write(`${YELLOW}warning: ${msg}${RESET}\n`);
+}
+
+export function error(msg: string): void {
+  process.stderr.write(`${RED}${msg}${RESET}\n`);
+}

package/src/utils/process.ts

@@ -0,0 +1,13 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+export async function exec(
+  cmd: string,
+  args: string[],
+  opts?: { cwd?: string },
+): Promise<string> {
+  const { stdout } = await execFileAsync(cmd, args, { ...opts, encoding: 'utf8' });
+  return stdout.trimEnd();
+}

package/tests/commands/forward.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { join } from 'node:path';
+import { writeFile } from 'node:fs/promises';
+import { forwardToGit } from '../../src/commands/forward';
+import { execGit } from '../../src/core/git';
+import { createTempGitRepo, removeTempDir } from '../helpers';
+
+describe('forwardToGit', () => {
+  let tempDir: string;
+  const originalCwd = process.cwd();
+
+  beforeEach(async () => {
+    tempDir = await createTempGitRepo();
+    process.chdir(tempDir);
+
+    // Set up a minimal shadow repo
+    const sgitDir = join(tempDir, '.sgit');
+    await execGit(['init', '--bare', sgitDir]);
+    await execGit(['config', 'core.bare', 'false'], { gitDir: sgitDir });
+    await execGit(['config', 'core.worktree', tempDir], { gitDir: sgitDir });
+    await execGit(['config', 'user.email', 'test@test.com'], { gitDir: sgitDir });
+    await execGit(['config', 'user.name', 'Test'], { gitDir: sgitDir });
+
+    await writeFile(join(tempDir, '.sgit.json'), '{"paths":[]}');
+    await execGit(['add', '-f', '.sgit.json'], {
+      gitDir: sgitDir,
+      workTree: tempDir,
+    });
+    await execGit(['commit', '-m', 'init'], {
+      gitDir: sgitDir,
+      workTree: tempDir,
+    });
+  });
+
+  afterEach(async () => {
+    process.chdir(originalCwd);
+    await removeTempDir(tempDir);
+  });
+
+  it('forwards git commands to shadow repo and returns exit code', () => {
+    const exitCode = forwardToGit(tempDir, ['log', '--oneline']);
+    expect(exitCode).toBe(0);
+  });
+
+  it('returns non-zero exit code for failing commands', () => {
+    const exitCode = forwardToGit(tempDir, ['log', '--invalid-flag-xyz']);
+    expect(exitCode).not.toBe(0);
+  });
+
+  it('uses .sgit as git-dir', () => {
+    // rev-parse --git-dir should show the .sgit path
+    const exitCode = forwardToGit(tempDir, ['rev-parse', '--git-dir']);
+    expect(exitCode).toBe(0);
+  });
+});

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

@@ -0,0 +1,148 @@
+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 { readManifest } from '../../../src/core/manifest';
+import { execGit } from '../../../src/core/git';
+import { createTempGitRepo, removeTempDir } from '../../helpers';
+
+describe('track add', () => {
+  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 a file to shadow tracking', async () => {
+    await mkdir(join(tempDir, 'notes'), { recursive: true });
+    await writeFile(join(tempDir, 'notes', 'todo.md'), 'hello');
+
+    await trackAdd(['notes/todo.md']);
+
+    // In manifest
+    const manifest = await readManifest(tempDir);
+    expect(manifest.paths).toContain('notes/todo.md');
+
+    // Staged in shadow repo
+    const staged = await execGit(['diff', '--cached', '--name-only'], {
+      gitDir: join(tempDir, '.sgit'),
+      workTree: tempDir,
+    });
+    expect(staged).toContain('notes/todo.md');
+
+    // Excluded from main git
+    const mainExclude = await readFile(
+      join(tempDir, '.git', 'info', 'exclude'),
+      'utf-8',
+    );
+    expect(mainExclude).toContain('# sgit\nnotes/todo.md\n');
+  });
+
+  it('adds a directory with trailing slash', async () => {
+    await mkdir(join(tempDir, 'docs', '.internal'), { recursive: true });
+    await writeFile(
+      join(tempDir, 'docs', '.internal', 'design.md'),
+      'notes',
+    );
+
+    await trackAdd(['docs/.internal']);
+
+    const manifest = await readManifest(tempDir);
+    expect(manifest.paths).toContain('docs/.internal/');
+  });
+
+  it('skips already tracked path', async () => {
+    await mkdir(join(tempDir, 'notes'), { recursive: true });
+    await writeFile(join(tempDir, 'notes', 'todo.md'), 'hello');
+
+    await trackAdd(['notes/todo.md']);
+    await trackAdd(['notes/todo.md']); // no-op
+
+    const manifest = await readManifest(tempDir);
+    const count = manifest.paths.filter((p) => p === 'notes/todo.md').length;
+    expect(count).toBe(1);
+  });
+
+  it('errors for nonexistent path', async () => {
+    await expect(trackAdd(['nonexistent.md'])).rejects.toThrow(
+      'path does not exist',
+    );
+  });
+
+  it('errors for main-git-tracked file', async () => {
+    await writeFile(join(tempDir, 'tracked.md'), 'hello');
+    await execGit(['add', 'tracked.md'], { cwd: tempDir });
+    await execGit(['commit', '-m', 'add tracked'], { cwd: tempDir });
+
+    await expect(trackAdd(['tracked.md'])).rejects.toThrow(
+      'tracked by the main repository',
+    );
+  });
+
+  it('adopts a main-git-tracked file with --adopt', async () => {
+    await writeFile(join(tempDir, 'config.json'), '{"key": "value"}');
+    await execGit(['add', 'config.json'], { cwd: tempDir });
+    await execGit(['commit', '-m', 'add config'], { cwd: tempDir });
+
+    await trackAdd(['config.json'], { adopt: true });
+
+    // Removed from main git index
+    const mainFiles = await execGit(['ls-files'], { cwd: tempDir });
+    expect(mainFiles).not.toContain('config.json');
+
+    // In manifest
+    const manifest = await readManifest(tempDir);
+    expect(manifest.paths).toContain('config.json');
+
+    // Staged in shadow repo
+    const staged = await execGit(['diff', '--cached', '--name-only'], {
+      gitDir: join(tempDir, '.sgit'),
+      workTree: tempDir,
+    });
+    expect(staged).toContain('config.json');
+
+    // File still on disk
+    await access(join(tempDir, 'config.json'), constants.F_OK);
+  });
+
+  it('adopts a main-git-tracked directory with --adopt', async () => {
+    await mkdir(join(tempDir, 'secrets'), { recursive: true });
+    await writeFile(join(tempDir, 'secrets', 'key.pem'), 'secret');
+    await execGit(['add', 'secrets/'], { cwd: tempDir });
+    await execGit(['commit', '-m', 'add secrets'], { cwd: tempDir });
+
+    await trackAdd(['secrets'], { adopt: true });
+
+    // Removed from main git index
+    const mainFiles = await execGit(['ls-files'], { cwd: tempDir });
+    expect(mainFiles).not.toContain('secrets/key.pem');
+
+    // In manifest
+    const manifest = await readManifest(tempDir);
+    expect(manifest.paths).toContain('secrets/');
+
+    // File still on disk
+    await access(join(tempDir, 'secrets', 'key.pem'), constants.F_OK);
+  });
+
+  it('adds multiple paths at once', async () => {
+    await writeFile(join(tempDir, 'a.txt'), 'a');
+    await writeFile(join(tempDir, 'b.txt'), 'b');
+
+    await trackAdd(['a.txt', 'b.txt']);
+
+    const manifest = await readManifest(tempDir);
+    expect(manifest.paths).toContain('a.txt');
+    expect(manifest.paths).toContain('b.txt');
+  });
+});

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

@@ -0,0 +1,124 @@
+import { describe, it, expect, afterEach, vi } from 'vitest';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import {
+  bashCompletion,
+  zshCompletion,
+  fishCompletion,
+  detectShell,
+  getInstallPath,
+  trackCompletion,
+} from '../../../src/commands/track/completion';
+
+describe('completion scripts', () => {
+  it('bash script dynamically sources git commands', () => {
+    const script = bashCompletion();
+    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('--adopt');
+    expect(script).toContain('sgit track list');
+    expect(script).toContain('__git_wrap__git_main');
+  });
+
+  it('zsh script delegates to _git for git commands', () => {
+    const script = zshCompletion();
+    expect(script).toContain('#compdef sgit');
+    expect(script).toContain('_sgit_track');
+    expect(script).toContain('--adopt');
+    expect(script).toContain('sgit track list');
+    expect(script).toContain('words[1]=git');
+    expect(script).toContain('_git');
+  });
+
+  it('fish script wraps git completions', () => {
+    const script = fishCompletion();
+    expect(script).toContain('complete -c sgit -w git');
+    expect(script).toContain('-l adopt');
+    expect(script).toContain('sgit track list');
+    expect(script).toContain('-l force');
+  });
+});
+
+describe('detectShell', () => {
+  const origShell = process.env.SHELL;
+
+  afterEach(() => {
+    if (origShell !== undefined) {
+      process.env.SHELL = origShell;
+    } else {
+      delete process.env.SHELL;
+    }
+  });
+
+  it('detects bash', () => {
+    process.env.SHELL = '/bin/bash';
+    expect(detectShell()).toBe('bash');
+  });
+
+  it('detects zsh', () => {
+    process.env.SHELL = '/usr/bin/zsh';
+    expect(detectShell()).toBe('zsh');
+  });
+
+  it('detects fish', () => {
+    process.env.SHELL = '/usr/bin/fish';
+    expect(detectShell()).toBe('fish');
+  });
+
+  it('defaults to bash', () => {
+    delete process.env.SHELL;
+    expect(detectShell()).toBe('bash');
+  });
+});
+
+describe('getInstallPath', () => {
+  const home = homedir();
+
+  it('returns bash path', () => {
+    expect(getInstallPath('bash')).toBe(
+      join(home, '.local', 'share', 'bash-completion', 'completions', 'sgit'),
+    );
+  });
+
+  it('returns zsh path', () => {
+    expect(getInstallPath('zsh')).toBe(
+      join(home, '.zsh', 'completions', '_sgit'),
+    );
+  });
+
+  it('returns fish path', () => {
+    expect(getInstallPath('fish')).toBe(
+      join(home, '.config', 'fish', 'completions', 'sgit.fish'),
+    );
+  });
+});
+
+describe('trackCompletion', () => {
+  it('prints script to stdout when no action', async () => {
+    const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    await trackCompletion(undefined, { shell: 'bash' });
+    expect(writeSpy).toHaveBeenCalledOnce();
+    expect(writeSpy.mock.calls[0][0]).toContain('complete -F _sgit sgit');
+    writeSpy.mockRestore();
+  });
+
+  it('installs to correct path', async () => {
+    const { mkdtemp, readFile, rm } = await import('node:fs/promises');
+    const { tmpdir } = await import('node:os');
+    const tempHome = await mkdtemp(join(tmpdir(), 'sgit-comp-'));
+    const origHome = process.env.HOME;
+    process.env.HOME = tempHome;
+
+    try {
+      await trackCompletion('install', { shell: 'bash' });
+      const expectedPath = join(tempHome, '.local', 'share', 'bash-completion', 'completions', 'sgit');
+      const content = await readFile(expectedPath, 'utf-8');
+      expect(content).toContain('complete -F _sgit sgit');
+    } finally {
+      process.env.HOME = origHome;
+      await rm(tempHome, { recursive: true });
+    }
+  });
+});

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

@@ -0,0 +1,112 @@
+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 { trackDestroy } from '../../../src/commands/track/destroy';
+import { createTempGitRepo, removeTempDir } from '../../helpers';
+
+describe('track destroy', () => {
+  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 .sgit and .sgit.json', async () => {
+    await trackDestroy({ force: true });
+
+    await expect(
+      access(join(tempDir, '.sgit'), constants.F_OK),
+    ).rejects.toThrow();
+    await expect(
+      access(join(tempDir, '.sgit.json'), constants.F_OK),
+    ).rejects.toThrow();
+  });
+
+  it('cleans sgit entries from .git/info/exclude', async () => {
+    // Add a user entry first
+    const excludePath = join(tempDir, '.git', 'info', 'exclude');
+    const before = await readFile(excludePath, 'utf-8');
+    // Write with a user entry preserved
+    await writeFile(excludePath, '*.log\n' + before.split('\n').slice(1).join('\n'));
+
+    await trackDestroy({ force: true });
+
+    const after = await readFile(excludePath, 'utf-8');
+    expect(after).not.toContain('# sgit\n');
+    expect(after).not.toContain('.sgit');
+  });
+
+  it('keeps previously tracked files on disk', async () => {
+    await writeFile(join(tempDir, 'notes.md'), 'keep me');
+    await trackAdd(['notes.md']);
+
+    await trackDestroy({ force: true });
+
+    // File remains
+    const content = await readFile(join(tempDir, 'notes.md'), 'utf-8');
+    expect(content).toBe('keep me');
+  });
+
+  it('restores original pre-commit hook', async () => {
+    // Reinit with a pre-existing hook
+    process.chdir(originalCwd);
+    await removeTempDir(tempDir);
+    tempDir = await createTempGitRepo();
+    process.chdir(tempDir);
+
+    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();
+    await trackDestroy({ force: true });
+
+    const hook = await readFile(join(hookDir, 'pre-commit'), 'utf-8');
+    expect(hook).toContain('echo original');
+    await expect(
+      access(join(hookDir, 'pre-commit.d'), constants.F_OK),
+    ).rejects.toThrow();
+  });
+
+  it('leaves other hooks in pre-commit.d', async () => {
+    const hookDir = join(tempDir, '.git', 'hooks');
+    await writeFile(
+      join(hookDir, 'pre-commit.d', 'lint'),
+      '#!/bin/sh\necho lint',
+      { mode: 0o755 },
+    );
+
+    await trackDestroy({ force: true });
+
+    // 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');
+  });
+
+  it('removes runner when pre-commit.d is empty after uninstall', async () => {
+    await trackDestroy({ force: true });
+
+    const hookDir = join(tempDir, '.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();
+  });
+});