shadow-git 0.1.0

package/src/commands/track/init.ts

@@ -0,0 +1,94 @@
+import { join } from 'node:path';
+import { mkdir, writeFile, readFile, access } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import {
+  findRoot,
+  validateNotWorktree,
+  validateNotSubmodule,
+} from '../../core/repository.js';
+import { execGit } from '../../core/git.js';
+import { writeManifest } from '../../core/manifest.js';
+import {
+  generateMainExclude,
+  generateShadowExclude,
+} from '../../core/exclude.js';
+import { installMainHook, installShadowHook } from '../../core/hooks.js';
+import { AlreadyInitializedError } from '../../core/errors.js';
+import * as logger from '../../utils/logger.js';
+
+export async function trackInit(): Promise<void> {
+  const root = await findRoot();
+  await validateNotWorktree(root);
+  await validateNotSubmodule(root);
+
+  const sgitDir = join(root, '.sgit');
+
+  // Check if already initialized
+  try {
+    await access(sgitDir, constants.F_OK);
+    throw new AlreadyInitializedError();
+  } catch (err) {
+    if (err instanceof AlreadyInitializedError) throw err;
+    // Not found — continue
+  }
+
+  // Create bare repo and configure
+  await execGit(['init', '--bare', sgitDir]);
+  await execGit(['config', 'core.bare', 'false'], { gitDir: sgitDir });
+  await execGit(['config', 'core.worktree', root], { gitDir: sgitDir });
+
+  // Copy user identity from main repo to shadow repo
+  try {
+    const name = await execGit(['config', 'user.name'], { cwd: root });
+    if (name) {
+      await execGit(['config', 'user.name', name], { gitDir: sgitDir });
+    }
+  } catch {
+    // Not configured in main repo
+  }
+  try {
+    const email = await execGit(['config', 'user.email'], { cwd: root });
+    if (email) {
+      await execGit(['config', 'user.email', email], { gitDir: sgitDir });
+    }
+  } catch {
+    // Not configured in main repo
+  }
+
+  // Generate .sgit/info/exclude
+  await mkdir(join(sgitDir, 'info'), { recursive: true });
+  await writeFile(
+    join(sgitDir, 'info', 'exclude'),
+    generateShadowExclude([]),
+  );
+
+  // Create .sgit.json
+  await writeManifest(root, { paths: [] });
+
+  // Update .git/info/exclude
+  const mainExcludePath = join(root, '.git', 'info', 'exclude');
+  let existingExclude = '';
+  try {
+    existingExclude = await readFile(mainExcludePath, 'utf-8');
+  } catch {
+    // File might not exist
+  }
+  await mkdir(join(root, '.git', 'info'), { recursive: true });
+  await writeFile(mainExcludePath, generateMainExclude(existingExclude, []));
+
+  // Install hooks
+  await installMainHook(root);
+  await installShadowHook(sgitDir);
+
+  // Stage and commit .sgit.json
+  await execGit(['add', '-f', '.sgit.json'], {
+    gitDir: sgitDir,
+    workTree: root,
+  });
+  await execGit(['commit', '-m', 'sgit: initialize shadow repository'], {
+    gitDir: sgitDir,
+    workTree: root,
+  });
+
+  logger.success('Shadow repository initialized at .sgit/');
+}

package/src/commands/track/list.ts

@@ -0,0 +1,15 @@
+import { findRoot, validateShadowRepo } from '../../core/repository.js';
+import { readManifest } from '../../core/manifest.js';
+import * as logger from '../../utils/logger.js';
+
+export async function trackList(): Promise<string[]> {
+  const root = await findRoot();
+  await validateShadowRepo(root);
+  const manifest = await readManifest(root);
+
+  for (const p of manifest.paths) {
+    logger.info(p);
+  }
+
+  return manifest.paths;
+}

package/src/commands/track/remove.ts

@@ -0,0 +1,66 @@
+import { join, resolve, relative, sep } from 'node:path';
+import { findRoot, validateShadowRepo } from '../../core/repository.js';
+import { execGit } from '../../core/git.js';
+import { removePath, readManifest } from '../../core/manifest.js';
+import { syncExcludes } from './sync.js';
+import { PathNotTrackedError } from '../../core/errors.js';
+import * as logger from '../../utils/logger.js';
+
+export async function trackRemove(paths: string[]): Promise<void> {
+  const root = await findRoot();
+  await validateShadowRepo(root);
+  const sgitDir = join(root, '.sgit');
+
+  const removed: string[] = [];
+
+  for (const inputPath of paths) {
+    // Normalize without stat (file may be deleted from disk)
+    const absolute = resolve(process.cwd(), inputPath);
+    let normalized = relative(root, absolute).split(sep).join('/');
+    if (inputPath.endsWith('/') && !normalized.endsWith('/')) {
+      normalized += '/';
+    }
+
+    // Find exact matching path in manifest (try with/without trailing slash)
+    const manifest = await readManifest(root);
+    const exactPath =
+      manifest.paths.find((p) => p === normalized) ||
+      manifest.paths.find((p) => p === normalized + '/') ||
+      (normalized.endsWith('/')
+        ? manifest.paths.find((p) => p === normalized.slice(0, -1))
+        : undefined);
+
+    if (!exactPath) {
+      throw new PathNotTrackedError(normalized);
+    }
+
+    const wasRemoved = await removePath(root, exactPath);
+    if (wasRemoved) {
+      removed.push(exactPath);
+
+      // Remove from shadow repo index
+      const rmPath = exactPath.endsWith('/')
+        ? exactPath.slice(0, -1)
+        : exactPath;
+      try {
+        const rmArgs = exactPath.endsWith('/')
+          ? ['rm', '--cached', '-r', rmPath]
+          : ['rm', '--cached', rmPath];
+        await execGit(rmArgs, { gitDir: sgitDir, workTree: root });
+      } catch {
+        // Might not be in index (never committed)
+      }
+    }
+  }
+
+  // Sync exclude files
+  await syncExcludes(root);
+
+  // Print summary
+  if (removed.length > 0) {
+    logger.success(`Removed ${removed.length} path(s) from shadow tracking:`);
+    for (const p of removed) {
+      logger.info(`  ${p}`);
+    }
+  }
+}

package/src/commands/track/sync.ts

@@ -0,0 +1,50 @@
+import { join } from 'node:path';
+import { writeFile, readFile, mkdir, access } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { findRoot, validateShadowRepo } from '../../core/repository.js';
+import { readManifest } from '../../core/manifest.js';
+import {
+  generateMainExclude,
+  generateShadowExclude,
+} from '../../core/exclude.js';
+import * as logger from '../../utils/logger.js';
+
+export async function syncExcludes(root: string): Promise<void> {
+  const manifest = await readManifest(root);
+
+  // Regenerate .git/info/exclude
+  const mainExcludePath = join(root, '.git', 'info', 'exclude');
+  let existingExclude = '';
+  try {
+    existingExclude = await readFile(mainExcludePath, 'utf-8');
+  } catch {
+    // File might not exist
+  }
+  await mkdir(join(root, '.git', 'info'), { recursive: true });
+  await writeFile(
+    mainExcludePath,
+    generateMainExclude(existingExclude, manifest.paths),
+  );
+
+  // Regenerate .sgit/info/exclude
+  const sgitExcludePath = join(root, '.sgit', 'info', 'exclude');
+  await mkdir(join(root, '.sgit', 'info'), { recursive: true });
+  await writeFile(sgitExcludePath, generateShadowExclude(manifest.paths));
+
+  // Warn for missing paths
+  for (const p of manifest.paths) {
+    const checkPath = p.endsWith('/') ? p.slice(0, -1) : p;
+    try {
+      await access(join(root, checkPath), constants.F_OK);
+    } catch {
+      logger.warn(`path does not exist: ${p}`);
+    }
+  }
+}
+
+export async function trackSync(): Promise<void> {
+  const root = await findRoot();
+  await validateShadowRepo(root);
+  await syncExcludes(root);
+  logger.success('Exclude files regenerated from .sgit.json');
+}

package/src/commands/track/verify.ts

@@ -0,0 +1,98 @@
+import { join } from 'node:path';
+import { findRoot, validateShadowRepo } from '../../core/repository.js';
+import { execGit } from '../../core/git.js';
+import { readManifest } from '../../core/manifest.js';
+import { isPathCoveredByManifest } from '../../core/paths.js';
+import { SgitError } from '../../core/errors.js';
+import * as logger from '../../utils/logger.js';
+
+export interface VerifyResult {
+  valid: boolean;
+  violations: string[];
+}
+
+export async function verifyMain(root: string): Promise<VerifyResult> {
+  const manifest = await readManifest(root);
+  let staged: string;
+  try {
+    staged = await execGit(['diff', '--cached', '--name-only'], {
+      gitDir: join(root, '.git'),
+      workTree: root,
+    });
+  } catch {
+    return { valid: true, violations: [] };
+  }
+
+  if (!staged.trim()) return { valid: true, violations: [] };
+
+  const stagedFiles = staged.trim().split('\n');
+  const violations = stagedFiles.filter((f) =>
+    isPathCoveredByManifest(f, manifest.paths),
+  );
+
+  return { valid: violations.length === 0, violations };
+}
+
+export async function verifyShadow(root: string): Promise<VerifyResult> {
+  const manifest = await readManifest(root);
+  let staged: string;
+  try {
+    staged = await execGit(['diff', '--cached', '--name-only'], {
+      gitDir: join(root, '.sgit'),
+      workTree: root,
+    });
+  } catch {
+    return { valid: true, violations: [] };
+  }
+
+  if (!staged.trim()) return { valid: true, violations: [] };
+
+  const stagedFiles = staged.trim().split('\n');
+  const violations = stagedFiles.filter(
+    (f) => f !== '.sgit.json' && !isPathCoveredByManifest(f, manifest.paths),
+  );
+
+  return { valid: violations.length === 0, violations };
+}
+
+export async function trackVerify(opts: {
+  main?: boolean;
+  shadow?: boolean;
+}): Promise<void> {
+  const root = await findRoot();
+  await validateShadowRepo(root);
+
+  if (!opts.main && !opts.shadow) {
+    throw new SgitError('specify --main or --shadow');
+  }
+
+  if (opts.main) {
+    const result = await verifyMain(root);
+    if (!result.valid) {
+      throw new SgitError(
+        [
+          'ERROR: The following files are tracked by shadow git and cannot be committed to the main repository:',
+          '',
+          ...result.violations.map((f) => `  ${f}`),
+          '',
+          "Remove them with 'git reset HEAD <file>', or untrack from sgit with 'sgit track remove <path>'.",
+        ].join('\n'),
+      );
+    }
+  }
+
+  if (opts.shadow) {
+    const result = await verifyShadow(root);
+    if (!result.valid) {
+      throw new SgitError(
+        [
+          'ERROR: The following files are not listed in .sgit.json and cannot be committed to the shadow repository:',
+          '',
+          ...result.violations.map((f) => `  ${f}`),
+          '',
+          "Add them with 'sgit track add <path>' first.",
+        ].join('\n'),
+      );
+    }
+  }
+}

package/src/core/errors.ts

@@ -0,0 +1,42 @@
+export class SgitError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'SgitError';
+  }
+}
+
+export class NotGitRepoError extends SgitError {
+  constructor() {
+    super('not a git repository');
+  }
+}
+
+export class AlreadyInitializedError extends SgitError {
+  constructor() {
+    super('shadow repository already initialized');
+  }
+}
+
+export class NotInitializedError extends SgitError {
+  constructor() {
+    super('not a shadow git repository; run \'sgit track init\' first');
+  }
+}
+
+export class PathNotFoundError extends SgitError {
+  constructor(path: string) {
+    super(`path does not exist: ${path}`);
+  }
+}
+
+export class PathTrackedByMainError extends SgitError {
+  constructor(path: string) {
+    super(`${path} is tracked by the main repository. Use 'sgit track add --adopt ${path}' to move it to shadow tracking.`);
+  }
+}
+
+export class PathNotTrackedError extends SgitError {
+  constructor(path: string) {
+    super(`${path} is not tracked by sgit`);
+  }
+}

package/src/core/exclude.ts

@@ -0,0 +1,106 @@
+export const SGIT_MARKER = '# sgit';
+export const SGIT_MANAGED_HEADER = '# sgit-managed (do not edit below this line)';
+
+export function generateMainExclude(
+  existingContent: string,
+  manifestPaths: string[],
+): string {
+  // Preserve non-sgit lines, stripping marker lines and their associated entries
+  const lines = existingContent.split('\n');
+  const preserved: string[] = [];
+  let skipNext = false;
+  for (const line of lines) {
+    if (line === SGIT_MANAGED_HEADER) {
+      skipNext = false;
+      continue;
+    }
+    if (line === SGIT_MARKER) {
+      skipNext = true;
+      continue;
+    }
+    // Strip legacy inline-comment format: "entry # sgit"
+    if (line.endsWith(` ${SGIT_MARKER}`)) {
+      continue;
+    }
+    if (skipNext) {
+      skipNext = false;
+      continue;
+    }
+    preserved.push(line);
+  }
+
+  // Trim trailing empty lines from preserved content
+  while (preserved.length > 0 && preserved[preserved.length - 1].trim() === '') {
+    preserved.pop();
+  }
+
+  const sgitEntries = ['.sgit', '.sgit.json', ...manifestPaths];
+  const sgitLines = sgitEntries.flatMap((entry) => [SGIT_MARKER, entry]);
+
+  const sections = [
+    ...preserved,
+    '',
+    SGIT_MANAGED_HEADER,
+    ...sgitLines,
+  ];
+
+  return sections.join('\n') + '\n';
+}
+
+export function generateShadowExclude(manifestPaths: string[]): string {
+  const lines: string[] = [
+    '# Exclude everything by default',
+    '*',
+    '',
+    '# .sgit.json (always tracked)',
+    '!.sgit.json',
+  ];
+
+  const emitted = new Set<string>();
+
+  for (const trackedPath of manifestPaths) {
+    const pathLines: string[] = [];
+    const ancestors = getAncestors(trackedPath);
+
+    for (const ancestor of ancestors) {
+      const unignore = `!${ancestor}/`;
+      const reignore = `${ancestor}/*`;
+      if (!emitted.has(unignore)) {
+        pathLines.push(unignore);
+        emitted.add(unignore);
+      }
+      if (!emitted.has(reignore)) {
+        pathLines.push(reignore);
+        emitted.add(reignore);
+      }
+    }
+
+    const target = `!${trackedPath}`;
+    if (!emitted.has(target)) {
+      pathLines.push(target);
+      emitted.add(target);
+    }
+
+    if (pathLines.length > 0) {
+      lines.push('');
+      lines.push(`# ${trackedPath}`);
+      lines.push(...pathLines);
+    }
+  }
+
+  return lines.join('\n') + '\n';
+}
+
+function getAncestors(path: string): string[] {
+  // Remove trailing slash for directories
+  const cleanPath = path.endsWith('/') ? path.slice(0, -1) : path;
+  const parts = cleanPath.split('/');
+  // Remove the last part (the file/dir itself)
+  parts.pop();
+
+  const ancestors: string[] = [];
+  for (let i = 1; i <= parts.length; i++) {
+    ancestors.push(parts.slice(0, i).join('/'));
+  }
+  return ancestors;
+}

package/src/core/git.ts

@@ -0,0 +1,18 @@
+import { exec } from '../utils/process.js';
+
+export interface GitOptions {
+  gitDir?: string;
+  workTree?: string;
+  cwd?: string;
+}
+
+export async function execGit(
+  args: string[],
+  opts?: GitOptions,
+): Promise<string> {
+  const gitArgs: string[] = [];
+  if (opts?.gitDir) gitArgs.push(`--git-dir=${opts.gitDir}`);
+  if (opts?.workTree) gitArgs.push(`--work-tree=${opts.workTree}`);
+  gitArgs.push(...args);
+  return exec('git', gitArgs, { cwd: opts?.cwd });
+}

package/src/core/hooks.ts

@@ -0,0 +1,152 @@
+import { join, resolve as resolvePath, dirname } from 'node:path';
+import {
+  mkdir,
+  writeFile,
+  readFile,
+  rename,
+  access,
+  lstat,
+  unlink,
+  copyFile,
+  chmod,
+  rm,
+  readdir,
+} from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { execGit } from './git.js';
+
+const RUNNER_SCRIPT = `#!/bin/sh
+# sgit hook runner — executes all hooks in pre-commit.d/
+dir="$(dirname "$0")/pre-commit.d"
+for hook in "$dir"/*; do
+  [ -f "$hook" ] && [ -x "$hook" ] || continue
+  "$hook"
+  status=$?
+  [ $status -ne 0 ] && exit $status
+done
+exit 0
+`;
+
+const MAIN_HOOK = `#!/bin/sh
+if command -v sgit >/dev/null 2>&1; then
+  sgit track verify --main
+else
+  echo "sgit: not found in PATH, skipping pre-commit check" >&2
+fi
+`;
+
+const SHADOW_HOOK = `#!/bin/sh
+if command -v sgit >/dev/null 2>&1; then
+  sgit track verify --shadow
+else
+  echo "sgit: not found in PATH, skipping pre-commit check" >&2
+fi
+`;
+
+export async function getHookDir(root: string): Promise<string> {
+  try {
+    const hookPath = await execGit(['config', 'core.hooksPath'], {
+      cwd: root,
+    });
+    if (hookPath) {
+      return resolvePath(root, hookPath);
+    }
+  } catch {
+    // Not configured
+  }
+  return join(root, '.git', 'hooks');
+}
+
+export async function installMainHook(root: string): Promise<void> {
+  const hookDir = await getHookDir(root);
+  const preCommitPath = join(hookDir, 'pre-commit');
+  const preCommitDDir = join(hookDir, 'pre-commit.d');
+  const sgitHookPath = join(preCommitDDir, 'sgit');
+
+  // Case: pre-commit.d already exists
+  if (await exists(preCommitDDir)) {
+    await writeFile(sgitHookPath, MAIN_HOOK, { mode: 0o755 });
+    return;
+  }
+
+  // Check if pre-commit exists
+  const hookExists = await exists(preCommitPath);
+
+  // Create pre-commit.d
+  await mkdir(preCommitDDir, { recursive: true });
+
+  if (hookExists) {
+    const stats = await lstat(preCommitPath);
+    if (stats.isSymbolicLink()) {
+      // Resolve symlink and copy content
+      await copyFile(preCommitPath, join(preCommitDDir, 'original'));
+      await chmod(join(preCommitDDir, 'original'), 0o755);
+      await unlink(preCommitPath);
+    } else {
+      // Move existing file
+      await rename(preCommitPath, join(preCommitDDir, 'original'));
+    }
+  }
+
+  // Write runner script
+  await writeFile(preCommitPath, RUNNER_SCRIPT, { mode: 0o755 });
+
+  // Write sgit hook
+  await writeFile(sgitHookPath, MAIN_HOOK, { mode: 0o755 });
+}
+
+export async function installShadowHook(sgitDir: string): Promise<void> {
+  const hooksDir = join(sgitDir, 'hooks');
+  await mkdir(hooksDir, { recursive: true });
+  await writeFile(join(hooksDir, 'pre-commit'), SHADOW_HOOK, { mode: 0o755 });
+}
+
+export async function uninstallMainHook(root: string): Promise<void> {
+  const hookDir = await getHookDir(root);
+  const preCommitPath = join(hookDir, 'pre-commit');
+  const preCommitDDir = join(hookDir, 'pre-commit.d');
+  const sgitHookPath = join(preCommitDDir, 'sgit');
+  const originalPath = join(preCommitDDir, 'original');
+
+  // Remove sgit hook
+  try {
+    await unlink(sgitHookPath);
+  } catch {
+    return; // Nothing to uninstall
+  }
+
+  // Check what remains in pre-commit.d/
+  let remaining: string[] = [];
+  try {
+    remaining = await readdir(preCommitDDir);
+  } catch {
+    // Directory might not exist
+  }
+
+  const hasOriginal = remaining.includes('original');
+  const hasOtherHooks = remaining.some((e) => e !== 'original');
+
+  if (hasOriginal && !hasOtherHooks) {
+    // Only original left — restore it as pre-commit, clean up directory
+    await rename(originalPath, preCommitPath);
+    await rm(preCommitDDir, { recursive: true });
+  } else if (remaining.length === 0) {
+    // Empty directory — remove it and the runner
+    await rm(preCommitDDir, { recursive: true });
+    try {
+      await unlink(preCommitPath);
+    } catch {
+      // Runner might not exist
+    }
+  }
+  // If other hooks remain (with or without original), leave runner and directory
+}
+
+async function exists(path: string): Promise<boolean> {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/core/manifest.ts

@@ -0,0 +1,49 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+export interface Manifest {
+  paths: string[];
+  [key: string]: unknown;
+}
+
+export async function readManifest(root: string): Promise<Manifest> {
+  const content = await readFile(join(root, '.sgit.json'), 'utf-8');
+  return JSON.parse(content) as Manifest;
+}
+
+export async function writeManifest(
+  root: string,
+  data: Manifest,
+): Promise<void> {
+  await writeFile(
+    join(root, '.sgit.json'),
+    JSON.stringify(data, null, 2) + '\n',
+  );
+}
+
+export async function addPath(
+  root: string,
+  normalizedPath: string,
+): Promise<boolean> {
+  const manifest = await readManifest(root);
+  if (manifest.paths.includes(normalizedPath)) {
+    return false;
+  }
+  manifest.paths.push(normalizedPath);
+  await writeManifest(root, manifest);
+  return true;
+}
+
+export async function removePath(
+  root: string,
+  normalizedPath: string,
+): Promise<boolean> {
+  const manifest = await readManifest(root);
+  const index = manifest.paths.indexOf(normalizedPath);
+  if (index === -1) {
+    return false;
+  }
+  manifest.paths.splice(index, 1);
+  await writeManifest(root, manifest);
+  return true;
+}