shadow-git 0.1.0

package/dist/cli.js

@@ -0,0 +1,1052 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/core/repository.ts
+import { access, lstat } from "fs/promises";
+import { constants } from "fs";
+import { join, resolve } from "path";
+
+// src/utils/process.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function exec(cmd, args, opts) {
+  const { stdout } = await execFileAsync(cmd, args, { ...opts, encoding: "utf8" });
+  return stdout.trimEnd();
+}
+
+// src/core/git.ts
+async function execGit(args, opts) {
+  const gitArgs = [];
+  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 });
+}
+
+// src/core/errors.ts
+var SgitError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SgitError";
+  }
+};
+var NotGitRepoError = class extends SgitError {
+  constructor() {
+    super("not a git repository");
+  }
+};
+var AlreadyInitializedError = class extends SgitError {
+  constructor() {
+    super("shadow repository already initialized");
+  }
+};
+var NotInitializedError = class extends SgitError {
+  constructor() {
+    super("not a shadow git repository; run 'sgit track init' first");
+  }
+};
+var PathNotFoundError = class extends SgitError {
+  constructor(path) {
+    super(`path does not exist: ${path}`);
+  }
+};
+var PathTrackedByMainError = class extends SgitError {
+  constructor(path) {
+    super(`${path} is tracked by the main repository. Use 'sgit track add --adopt ${path}' to move it to shadow tracking.`);
+  }
+};
+var PathNotTrackedError = class extends SgitError {
+  constructor(path) {
+    super(`${path} is not tracked by sgit`);
+  }
+};
+
+// src/core/repository.ts
+async function findRoot() {
+  try {
+    return await execGit(["rev-parse", "--show-toplevel"]);
+  } catch {
+    throw new NotGitRepoError();
+  }
+}
+async function validateShadowRepo(root) {
+  try {
+    await access(join(root, ".sgit"), constants.F_OK);
+  } catch {
+    throw new NotInitializedError();
+  }
+}
+async function validateNotWorktree(root) {
+  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");
+  }
+}
+async function validateNotSubmodule(root) {
+  const gitPath = join(root, ".git");
+  const stats = await lstat(gitPath);
+  if (!stats.isDirectory()) {
+    throw new SgitError("shadow git is not supported inside git submodules");
+  }
+}
+
+// src/commands/forward.ts
+import { spawnSync } from "child_process";
+import { join as join2 } from "path";
+function forwardToGit(root, args) {
+  const sgitDir = join2(root, ".sgit");
+  const result = spawnSync(
+    "git",
+    [`--git-dir=${sgitDir}`, `--work-tree=${root}`, ...args],
+    { stdio: "inherit" }
+  );
+  return result.status ?? 1;
+}
+
+// src/utils/logger.ts
+var RESET = "\x1B[0m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var RED = "\x1B[31m";
+var CYAN = "\x1B[36m";
+function info(msg) {
+  process.stdout.write(`${CYAN}${msg}${RESET}
+`);
+}
+function success(msg) {
+  process.stdout.write(`${GREEN}${msg}${RESET}
+`);
+}
+function warn(msg) {
+  process.stderr.write(`${YELLOW}warning: ${msg}${RESET}
+`);
+}
+function error(msg) {
+  process.stderr.write(`${RED}${msg}${RESET}
+`);
+}
+
+// src/commands/track/init.ts
+import { join as join5 } from "path";
+import { mkdir as mkdir2, writeFile as writeFile3, readFile as readFile3, access as access3 } from "fs/promises";
+import { constants as constants3 } from "fs";
+
+// src/core/manifest.ts
+import { readFile, writeFile } from "fs/promises";
+import { join as join3 } from "path";
+async function readManifest(root) {
+  const content = await readFile(join3(root, ".sgit.json"), "utf-8");
+  return JSON.parse(content);
+}
+async function writeManifest(root, data) {
+  await writeFile(
+    join3(root, ".sgit.json"),
+    JSON.stringify(data, null, 2) + "\n"
+  );
+}
+async function addPath(root, normalizedPath) {
+  const manifest = await readManifest(root);
+  if (manifest.paths.includes(normalizedPath)) {
+    return false;
+  }
+  manifest.paths.push(normalizedPath);
+  await writeManifest(root, manifest);
+  return true;
+}
+async function removePath(root, normalizedPath) {
+  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;
+}
+
+// src/core/exclude.ts
+var SGIT_MARKER = "# sgit";
+var SGIT_MANAGED_HEADER = "# sgit-managed (do not edit below this line)";
+function generateMainExclude(existingContent, manifestPaths) {
+  const lines = existingContent.split("\n");
+  const preserved = [];
+  let skipNext = false;
+  for (const line of lines) {
+    if (line === SGIT_MANAGED_HEADER) {
+      skipNext = false;
+      continue;
+    }
+    if (line === SGIT_MARKER) {
+      skipNext = true;
+      continue;
+    }
+    if (line.endsWith(` ${SGIT_MARKER}`)) {
+      continue;
+    }
+    if (skipNext) {
+      skipNext = false;
+      continue;
+    }
+    preserved.push(line);
+  }
+  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";
+}
+function generateShadowExclude(manifestPaths) {
+  const lines = [
+    "# Exclude everything by default",
+    "*",
+    "",
+    "# .sgit.json (always tracked)",
+    "!.sgit.json"
+  ];
+  const emitted = /* @__PURE__ */ new Set();
+  for (const trackedPath of manifestPaths) {
+    const pathLines = [];
+    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) {
+  const cleanPath = path.endsWith("/") ? path.slice(0, -1) : path;
+  const parts = cleanPath.split("/");
+  parts.pop();
+  const ancestors = [];
+  for (let i = 1; i <= parts.length; i++) {
+    ancestors.push(parts.slice(0, i).join("/"));
+  }
+  return ancestors;
+}
+
+// src/core/hooks.ts
+import { join as join4, resolve as resolvePath } from "path";
+import {
+  mkdir,
+  writeFile as writeFile2,
+  rename,
+  access as access2,
+  lstat as lstat2,
+  unlink,
+  copyFile,
+  chmod,
+  rm,
+  readdir
+} from "fs/promises";
+import { constants as constants2 } from "fs";
+var RUNNER_SCRIPT = `#!/bin/sh
+# sgit hook runner \u2014 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
+`;
+var 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
+`;
+var 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
+`;
+async function getHookDir(root) {
+  try {
+    const hookPath = await execGit(["config", "core.hooksPath"], {
+      cwd: root
+    });
+    if (hookPath) {
+      return resolvePath(root, hookPath);
+    }
+  } catch {
+  }
+  return join4(root, ".git", "hooks");
+}
+async function installMainHook(root) {
+  const hookDir = await getHookDir(root);
+  const preCommitPath = join4(hookDir, "pre-commit");
+  const preCommitDDir = join4(hookDir, "pre-commit.d");
+  const sgitHookPath = join4(preCommitDDir, "sgit");
+  if (await exists(preCommitDDir)) {
+    await writeFile2(sgitHookPath, MAIN_HOOK, { mode: 493 });
+    return;
+  }
+  const hookExists = await exists(preCommitPath);
+  await mkdir(preCommitDDir, { recursive: true });
+  if (hookExists) {
+    const stats = await lstat2(preCommitPath);
+    if (stats.isSymbolicLink()) {
+      await copyFile(preCommitPath, join4(preCommitDDir, "original"));
+      await chmod(join4(preCommitDDir, "original"), 493);
+      await unlink(preCommitPath);
+    } else {
+      await rename(preCommitPath, join4(preCommitDDir, "original"));
+    }
+  }
+  await writeFile2(preCommitPath, RUNNER_SCRIPT, { mode: 493 });
+  await writeFile2(sgitHookPath, MAIN_HOOK, { mode: 493 });
+}
+async function installShadowHook(sgitDir) {
+  const hooksDir = join4(sgitDir, "hooks");
+  await mkdir(hooksDir, { recursive: true });
+  await writeFile2(join4(hooksDir, "pre-commit"), SHADOW_HOOK, { mode: 493 });
+}
+async function uninstallMainHook(root) {
+  const hookDir = await getHookDir(root);
+  const preCommitPath = join4(hookDir, "pre-commit");
+  const preCommitDDir = join4(hookDir, "pre-commit.d");
+  const sgitHookPath = join4(preCommitDDir, "sgit");
+  const originalPath = join4(preCommitDDir, "original");
+  try {
+    await unlink(sgitHookPath);
+  } catch {
+    return;
+  }
+  let remaining = [];
+  try {
+    remaining = await readdir(preCommitDDir);
+  } catch {
+  }
+  const hasOriginal = remaining.includes("original");
+  const hasOtherHooks = remaining.some((e) => e !== "original");
+  if (hasOriginal && !hasOtherHooks) {
+    await rename(originalPath, preCommitPath);
+    await rm(preCommitDDir, { recursive: true });
+  } else if (remaining.length === 0) {
+    await rm(preCommitDDir, { recursive: true });
+    try {
+      await unlink(preCommitPath);
+    } catch {
+    }
+  }
+}
+async function exists(path) {
+  try {
+    await access2(path, constants2.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/track/init.ts
+async function trackInit() {
+  const root = await findRoot();
+  await validateNotWorktree(root);
+  await validateNotSubmodule(root);
+  const sgitDir = join5(root, ".sgit");
+  try {
+    await access3(sgitDir, constants3.F_OK);
+    throw new AlreadyInitializedError();
+  } catch (err) {
+    if (err instanceof AlreadyInitializedError) throw err;
+  }
+  await execGit(["init", "--bare", sgitDir]);
+  await execGit(["config", "core.bare", "false"], { gitDir: sgitDir });
+  await execGit(["config", "core.worktree", root], { gitDir: sgitDir });
+  try {
+    const name = await execGit(["config", "user.name"], { cwd: root });
+    if (name) {
+      await execGit(["config", "user.name", name], { gitDir: sgitDir });
+    }
+  } catch {
+  }
+  try {
+    const email = await execGit(["config", "user.email"], { cwd: root });
+    if (email) {
+      await execGit(["config", "user.email", email], { gitDir: sgitDir });
+    }
+  } catch {
+  }
+  await mkdir2(join5(sgitDir, "info"), { recursive: true });
+  await writeFile3(
+    join5(sgitDir, "info", "exclude"),
+    generateShadowExclude([])
+  );
+  await writeManifest(root, { paths: [] });
+  const mainExcludePath = join5(root, ".git", "info", "exclude");
+  let existingExclude = "";
+  try {
+    existingExclude = await readFile3(mainExcludePath, "utf-8");
+  } catch {
+  }
+  await mkdir2(join5(root, ".git", "info"), { recursive: true });
+  await writeFile3(mainExcludePath, generateMainExclude(existingExclude, []));
+  await installMainHook(root);
+  await installShadowHook(sgitDir);
+  await execGit(["add", "-f", ".sgit.json"], {
+    gitDir: sgitDir,
+    workTree: root
+  });
+  await execGit(["commit", "-m", "sgit: initialize shadow repository"], {
+    gitDir: sgitDir,
+    workTree: root
+  });
+  success("Shadow repository initialized at .sgit/");
+}
+
+// src/commands/track/sync.ts
+import { join as join6 } from "path";
+import { writeFile as writeFile4, readFile as readFile4, mkdir as mkdir3, access as access4 } from "fs/promises";
+import { constants as constants4 } from "fs";
+async function syncExcludes(root) {
+  const manifest = await readManifest(root);
+  const mainExcludePath = join6(root, ".git", "info", "exclude");
+  let existingExclude = "";
+  try {
+    existingExclude = await readFile4(mainExcludePath, "utf-8");
+  } catch {
+  }
+  await mkdir3(join6(root, ".git", "info"), { recursive: true });
+  await writeFile4(
+    mainExcludePath,
+    generateMainExclude(existingExclude, manifest.paths)
+  );
+  const sgitExcludePath = join6(root, ".sgit", "info", "exclude");
+  await mkdir3(join6(root, ".sgit", "info"), { recursive: true });
+  await writeFile4(sgitExcludePath, generateShadowExclude(manifest.paths));
+  for (const p of manifest.paths) {
+    const checkPath = p.endsWith("/") ? p.slice(0, -1) : p;
+    try {
+      await access4(join6(root, checkPath), constants4.F_OK);
+    } catch {
+      warn(`path does not exist: ${p}`);
+    }
+  }
+}
+async function trackSync() {
+  const root = await findRoot();
+  await validateShadowRepo(root);
+  await syncExcludes(root);
+  success("Exclude files regenerated from .sgit.json");
+}
+
+// src/commands/track/add.ts
+import { join as join7 } from "path";
+import { access as access5 } from "fs/promises";
+import { constants as constants5 } from "fs";
+
+// src/core/paths.ts
+import { resolve as resolve2, relative, sep } from "path";
+import { stat } from "fs/promises";
+async function normalizePath(inputPath, root) {
+  const absolute = resolve2(process.cwd(), inputPath);
+  let rel = relative(root, absolute);
+  if (rel.startsWith("..")) {
+    throw new SgitError(`path is outside the project root: ${inputPath}`);
+  }
+  rel = rel.split(sep).join("/");
+  try {
+    const st = await stat(absolute);
+    if (st.isDirectory() && !rel.endsWith("/")) {
+      rel += "/";
+    }
+  } catch {
+    if (inputPath.endsWith("/") && !rel.endsWith("/")) {
+      rel += "/";
+    }
+  }
+  return rel;
+}
+function isPathCoveredByManifest(filePath, manifestPaths) {
+  const caseInsensitive = process.platform === "darwin";
+  const normalize = caseInsensitive ? (s) => s.toLowerCase() : (s) => 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;
+}
+
+// src/commands/track/add.ts
+async function trackAdd(paths, opts = {}) {
+  const root = await findRoot();
+  await validateShadowRepo(root);
+  const sgitDir = join7(root, ".sgit");
+  const added = [];
+  for (const inputPath of paths) {
+    const normalized = await normalizePath(inputPath, root);
+    const checkPath = normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+    try {
+      await access5(join7(root, checkPath), constants5.F_OK);
+    } catch {
+      throw new PathNotFoundError(normalized);
+    }
+    const manifest = await readManifest(root);
+    const alreadyTracked = manifest.paths.includes(normalized);
+    let trackedByMain = false;
+    try {
+      await execGit(["ls-files", "--error-unmatch", checkPath], {
+        gitDir: join7(root, ".git"),
+        workTree: root
+      });
+      trackedByMain = true;
+    } catch {
+    }
+    if (trackedByMain) {
+      if (opts.adopt && !alreadyTracked) {
+        const rmArgs = normalized.endsWith("/") ? ["rm", "--cached", "-r", checkPath] : ["rm", "--cached", checkPath];
+        await execGit(rmArgs, { gitDir: join7(root, ".git"), workTree: root });
+      } else if (!opts.adopt) {
+        throw new PathTrackedByMainError(normalized);
+      }
+    }
+    const wasAdded = await addPath(root, normalized);
+    if (wasAdded) {
+      added.push(normalized);
+    }
+  }
+  await syncExcludes(root);
+  for (const p of added) {
+    const gitPath = p.endsWith("/") ? p.slice(0, -1) : p;
+    await execGit(["add", "-f", gitPath], {
+      gitDir: sgitDir,
+      workTree: root
+    });
+  }
+  if (added.length > 0) {
+    success(`Tracking ${added.length} new path(s):`);
+    for (const p of added) {
+      info(`  ${p}`);
+    }
+  } else {
+    info("All paths already tracked.");
+  }
+}
+
+// src/commands/track/remove.ts
+import { join as join8, resolve as resolve3, relative as relative2, sep as sep2 } from "path";
+async function trackRemove(paths) {
+  const root = await findRoot();
+  await validateShadowRepo(root);
+  const sgitDir = join8(root, ".sgit");
+  const removed = [];
+  for (const inputPath of paths) {
+    const absolute = resolve3(process.cwd(), inputPath);
+    let normalized = relative2(root, absolute).split(sep2).join("/");
+    if (inputPath.endsWith("/") && !normalized.endsWith("/")) {
+      normalized += "/";
+    }
+    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)) : void 0);
+    if (!exactPath) {
+      throw new PathNotTrackedError(normalized);
+    }
+    const wasRemoved = await removePath(root, exactPath);
+    if (wasRemoved) {
+      removed.push(exactPath);
+      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 {
+      }
+    }
+  }
+  await syncExcludes(root);
+  if (removed.length > 0) {
+    success(`Removed ${removed.length} path(s) from shadow tracking:`);
+    for (const p of removed) {
+      info(`  ${p}`);
+    }
+  }
+}
+
+// src/commands/track/list.ts
+async function trackList() {
+  const root = await findRoot();
+  await validateShadowRepo(root);
+  const manifest = await readManifest(root);
+  for (const p of manifest.paths) {
+    info(p);
+  }
+  return manifest.paths;
+}
+
+// src/commands/track/verify.ts
+import { join as join9 } from "path";
+async function verifyMain(root) {
+  const manifest = await readManifest(root);
+  let staged;
+  try {
+    staged = await execGit(["diff", "--cached", "--name-only"], {
+      gitDir: join9(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 };
+}
+async function verifyShadow(root) {
+  const manifest = await readManifest(root);
+  let staged;
+  try {
+    staged = await execGit(["diff", "--cached", "--name-only"], {
+      gitDir: join9(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 };
+}
+async function trackVerify(opts) {
+  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")
+      );
+    }
+  }
+}
+
+// src/commands/track/destroy.ts
+import { join as join10 } from "path";
+import { readFile as readFile5, writeFile as writeFile5, rm as rm2 } from "fs/promises";
+import { createInterface } from "readline";
+async function trackDestroy(opts) {
+  const root = await findRoot();
+  await validateShadowRepo(root);
+  if (!opts.force) {
+    const confirmed = await confirm(
+      "This will permanently remove the shadow repository. Continue?"
+    );
+    if (!confirmed) {
+      info("Aborted.");
+      return;
+    }
+  }
+  const excludePath = join10(root, ".git", "info", "exclude");
+  try {
+    const content = await readFile5(excludePath, "utf-8");
+    const lines = content.split("\n");
+    const result = [];
+    let skipNext = false;
+    for (const line of lines) {
+      if (line === SGIT_MANAGED_HEADER) {
+        skipNext = false;
+        continue;
+      }
+      if (line === SGIT_MARKER) {
+        skipNext = true;
+        continue;
+      }
+      if (line.endsWith(` ${SGIT_MARKER}`)) {
+        continue;
+      }
+      if (skipNext) {
+        skipNext = false;
+        continue;
+      }
+      result.push(line);
+    }
+    const cleaned = result.join("\n");
+    await writeFile5(excludePath, cleaned.replace(/\n+$/, "\n"));
+  } catch {
+  }
+  await uninstallMainHook(root);
+  await rm2(join10(root, ".sgit"), { recursive: true, force: true });
+  await rm2(join10(root, ".sgit.json"), { force: true });
+  success("Shadow repository removed.");
+}
+async function confirm(message) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve4) => {
+    rl.question(`${message} [y/N] `, (answer) => {
+      rl.close();
+      resolve4(answer.toLowerCase() === "y");
+    });
+  });
+}
+
+// src/commands/track/completion.ts
+import { join as join11, dirname as dirname2 } from "path";
+import { mkdir as mkdir4, writeFile as writeFile6 } from "fs/promises";
+import { homedir } from "os";
+function bashCompletion() {
+  return `# sgit bash completion
+_sgit() {
+  local cur prev words cword
+  _init_completion || return
+
+  if [[ \${words[1]} == "track" ]]; then
+    if [[ $cword -eq 2 ]]; then
+      COMPREPLY=($(compgen -W "init add remove list sync verify destroy completion" -- "$cur"))
+      return
+    fi
+
+    local subcmd="\${words[2]}"
+    case "$subcmd" in
+      add)
+        if [[ $cur == -* ]]; then
+          COMPREPLY=($(compgen -W "--adopt" -- "$cur"))
+        else
+          _filedir
+        fi
+        ;;
+      remove)
+        local paths
+        paths=$(sgit track list 2>/dev/null)
+        COMPREPLY=($(compgen -W "$paths" -- "$cur"))
+        ;;
+      verify)
+        COMPREPLY=($(compgen -W "--main --shadow" -- "$cur"))
+        ;;
+      destroy)
+        COMPREPLY=($(compgen -W "--force" -- "$cur"))
+        ;;
+      completion)
+        if [[ $prev == "--shell" ]]; then
+          COMPREPLY=($(compgen -W "bash zsh fish" -- "$cur"))
+        elif [[ $cur == -* ]]; then
+          COMPREPLY=($(compgen -W "--shell" -- "$cur"))
+        else
+          COMPREPLY=($(compgen -W "install" -- "$cur"))
+        fi
+        ;;
+    esac
+    return
+  fi
+
+  if [[ $cword -eq 1 ]]; then
+    # "track" plus all git subcommands
+    local git_cmds
+    git_cmds=$(git --list-cmds=main,others 2>/dev/null)
+    COMPREPLY=($(compgen -W "track $git_cmds" -- "$cur"))
+    return
+  fi
+
+  # Non-track commands: delegate to git completion
+  if declare -f __git_wrap__git_main &>/dev/null; then
+    __git_wrap__git_main
+  elif declare -f _git &>/dev/null; then
+    _git
+  fi
+}
+complete -F _sgit sgit
+`;
+}
+function zshCompletion() {
+  return `#compdef sgit
+# sgit zsh completion
+
+_sgit_track() {
+  local -a subcmds
+  subcmds=(
+    'init:Initialize shadow repository'
+    'add:Start shadow-tracking paths'
+    'remove:Stop shadow-tracking paths'
+    'list:List all shadow-tracked paths'
+    'sync:Regenerate exclude files'
+    'verify:Validate staged files'
+    'destroy:Remove shadow repository'
+    'completion:Install shell completions'
+  )
+
+  if (( CURRENT == 2 )); then
+    _describe 'track subcommand' subcmds
+    return
+  fi
+
+  case "\${words[2]}" in
+    add)
+      _arguments '--adopt[Move main-git-tracked files to shadow tracking]' '*:file:_files'
+      ;;
+    remove)
+      local -a paths
+      paths=(\${(f)"$(sgit track list 2>/dev/null)"})
+      _describe 'tracked path' paths
+      ;;
+    verify)
+      _arguments '--main[Check main repo]' '--shadow[Check shadow repo]'
+      ;;
+    destroy)
+      _arguments '--force[Skip confirmation]'
+      ;;
+    completion)
+      _arguments '--shell[Shell type]:shell:(bash zsh fish)' '1:action:(install)'
+      ;;
+  esac
+}
+
+_sgit() {
+  if (( CURRENT == 2 )); then
+    local -a track_cmd
+    track_cmd=('track:Manage shadow-tracked paths')
+    _describe 'sgit command' track_cmd
+    # Also offer all git subcommands
+    words[1]=git
+    _git
+    return
+  fi
+
+  case "\${words[2]}" in
+    track)
+      (( CURRENT-- ))
+      shift words
+      _sgit_track
+      ;;
+    *)
+      words[1]=git
+      _git
+      ;;
+  esac
+}
+
+_sgit "$@"
+`;
+}
+function fishCompletion() {
+  return `# sgit fish completion
+
+# Inherit all git completions (sgit forwards non-track commands to git)
+complete -c sgit -w git
+
+# Add "track" as a top-level subcommand
+complete -c sgit -n '__fish_use_subcommand' -a track -d 'Manage shadow-tracked paths'
+
+# Track subcommands
+complete -c sgit -n '__fish_seen_subcommand_from track; and not __fish_seen_subcommand_from init add remove list sync verify destroy completion' -a init -d 'Initialize shadow repository'
+complete -c sgit -n '__fish_seen_subcommand_from track; and not __fish_seen_subcommand_from init add remove list sync verify destroy completion' -a add -d 'Start shadow-tracking paths'
+complete -c sgit -n '__fish_seen_subcommand_from track; and not __fish_seen_subcommand_from init add remove list sync verify destroy completion' -a remove -d 'Stop shadow-tracking paths'
+complete -c sgit -n '__fish_seen_subcommand_from track; and not __fish_seen_subcommand_from init add remove list sync verify destroy completion' -a list -d 'List all shadow-tracked paths'
+complete -c sgit -n '__fish_seen_subcommand_from track; and not __fish_seen_subcommand_from init add remove list sync verify destroy completion' -a sync -d 'Regenerate exclude files'
+complete -c sgit -n '__fish_seen_subcommand_from track; and not __fish_seen_subcommand_from init add remove list sync verify destroy completion' -a verify -d 'Validate staged files'
+complete -c sgit -n '__fish_seen_subcommand_from track; and not __fish_seen_subcommand_from init add remove list sync verify destroy completion' -a destroy -d 'Remove shadow repository'
+complete -c sgit -n '__fish_seen_subcommand_from track; and not __fish_seen_subcommand_from init add remove list sync verify destroy completion' -a completion -d 'Install shell completions'
+
+# Track add options and file completions
+complete -c sgit -n '__fish_seen_subcommand_from track; and __fish_seen_subcommand_from add' -l adopt -d 'Move main-git-tracked files'
+complete -c sgit -n '__fish_seen_subcommand_from track; and __fish_seen_subcommand_from add' -F
+
+# Track remove \u2014 complete from manifest
+complete -c sgit -n '__fish_seen_subcommand_from track; and __fish_seen_subcommand_from remove' -a '(sgit track list 2>/dev/null)'
+
+# Track verify options
+complete -c sgit -n '__fish_seen_subcommand_from track; and __fish_seen_subcommand_from verify' -l main -d 'Check main repo'
+complete -c sgit -n '__fish_seen_subcommand_from track; and __fish_seen_subcommand_from verify' -l shadow -d 'Check shadow repo'
+
+# Track destroy options
+complete -c sgit -n '__fish_seen_subcommand_from track; and __fish_seen_subcommand_from destroy' -l force -d 'Skip confirmation'
+
+# Track completion options
+complete -c sgit -n '__fish_seen_subcommand_from track; and __fish_seen_subcommand_from completion' -a install -d 'Install completions'
+complete -c sgit -n '__fish_seen_subcommand_from track; and __fish_seen_subcommand_from completion' -l shell -d 'Shell type' -ra 'bash zsh fish'
+`;
+}
+function detectShell() {
+  const shell = process.env.SHELL || "";
+  if (shell.includes("zsh")) return "zsh";
+  if (shell.includes("fish")) return "fish";
+  return "bash";
+}
+function getScript(shell) {
+  switch (shell) {
+    case "zsh":
+      return zshCompletion();
+    case "fish":
+      return fishCompletion();
+    default:
+      return bashCompletion();
+  }
+}
+function getInstallPath(shell) {
+  const home = homedir();
+  switch (shell) {
+    case "zsh":
+      return join11(home, ".zsh", "completions", "_sgit");
+    case "fish":
+      return join11(home, ".config", "fish", "completions", "sgit.fish");
+    default:
+      return join11(home, ".local", "share", "bash-completion", "completions", "sgit");
+  }
+}
+async function trackCompletion(action, opts) {
+  const shell = opts?.shell || detectShell();
+  const script = getScript(shell);
+  if (!action) {
+    process.stdout.write(script);
+    return;
+  }
+  if (action === "install") {
+    const installPath = getInstallPath(shell);
+    await mkdir4(dirname2(installPath), { recursive: true });
+    await writeFile6(installPath, script, { mode: 420 });
+    success(`Installed ${shell} completions to ${installPath}`);
+    if (shell === "zsh") {
+      info(
+        "Ensure ~/.zsh/completions is in your $fpath. Add to ~/.zshrc:\n  fpath=(~/.zsh/completions $fpath)\n  autoload -Uz compinit && compinit"
+      );
+    }
+    return;
+  }
+  error(`Unknown action: ${action}. Use 'install' or omit for stdout.`);
+  process.exit(1);
+}
+
+// src/commands/track/index.ts
+function registerTrackCommands(program) {
+  const track = program.command("track").description("Manage shadow-tracked paths");
+  track.command("init").description("Initialize shadow repository").action(wrapAction(trackInit));
+  track.command("add").description("Start shadow-tracking paths").argument("<paths...>").option("--adopt", "Move main-git-tracked files to shadow tracking").action(wrapAction(async (paths, opts) => trackAdd(paths, opts)));
+  track.command("remove").description("Stop shadow-tracking paths").argument("<paths...>").action(wrapAction(async (paths) => trackRemove(paths)));
+  track.command("list").description("List all shadow-tracked paths").action(wrapAction(async () => {
+    await trackList();
+  }));
+  track.command("sync").description("Regenerate exclude files from .sgit.json").action(wrapAction(trackSync));
+  track.command("verify").description("Validate staged files against manifest").option("--main", "Check main repo staged files").option("--shadow", "Check shadow repo staged files").action(
+    wrapAction(
+      async (opts) => trackVerify(opts)
+    )
+  );
+  track.command("destroy").description("Remove shadow repository entirely").option("--force", "Skip confirmation prompt").action(
+    wrapAction(async (opts) => trackDestroy(opts))
+  );
+  track.command("completion").description("Install shell completion scripts").argument("[action]", "Action (install)").option("--shell <name>", "Shell (bash, zsh, fish)").action(
+    wrapAction(
+      async (action, opts) => trackCompletion(action, opts)
+    )
+  );
+}
+function wrapAction(fn) {
+  return async (...args) => {
+    try {
+      await fn(...args);
+    } catch (err) {
+      if (err instanceof SgitError) {
+        error(err.message);
+        process.exit(1);
+      }
+      throw err;
+    }
+  };
+}
+
+// src/cli.ts
+async function run() {
+  const args = process.argv.slice(2);
+  if (args.length === 0 || args[0] === "track" || args[0].startsWith("-")) {
+    const program = new Command("sgit").description("Shadow Git \u2014 a secondary git repository for your project").version("0.1.0");
+    registerTrackCommands(program);
+    program.addHelpText(
+      "after",
+      `
+Track commands:
+  sgit track init          Initialize shadow repository
+  sgit track add           Start shadow-tracking paths (--adopt to move from main git)
+  sgit track remove        Stop shadow-tracking paths
+  sgit track list          List all shadow-tracked paths
+  sgit track sync          Regenerate exclude files
+  sgit track verify        Validate staged files
+  sgit track destroy       Remove shadow repository
+  sgit track completion    Install shell completions
+
+All other commands are forwarded to git in the shadow repository:
+  sgit status, sgit commit, sgit log, sgit diff, ...`
+    );
+    await program.parseAsync(process.argv);
+  } else {
+    const root = await findRoot();
+    await validateShadowRepo(root);
+    const exitCode = forwardToGit(root, args);
+    process.exit(exitCode);
+  }
+}
+run().catch((err) => {
+  if (err instanceof SgitError) {
+    error(err.message);
+  } else {
+    console.error(err);
+  }
+  process.exit(1);
+});