shadow-git 1.0.3 → 1.1.1

package/dist/cli.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 
 // src/cli.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { fileURLToPath } from "url";
 import { Command as Command2 } from "commander";
 
 // src/core/repository.ts
@@ -70,6 +72,44 @@ var PathNotTrackedError = class extends SgitError {
     super(`${path} is not tracked by sgit`);
   }
 };
+var StaleGitignoreError = class extends SgitError {
+  constructor(files) {
+    super(
+      [
+        "found stale .gitignore.sgit-parked files (a previous sgit command did not complete cleanly):",
+        ...files.map((f) => `  ${f}`),
+        "",
+        "rename them back to .gitignore manually, then retry."
+      ].join("\n")
+    );
+  }
+};
+var AlreadySwappedError = class extends SgitError {
+  constructor() {
+    super("shadow-git is already in swap mode; run 'sgit track unswap' to exit.");
+  }
+};
+var NotSwappedError = class extends SgitError {
+  constructor() {
+    super("shadow-git is not in swap mode.");
+  }
+};
+var SwapModeActiveError = class extends SgitError {
+  constructor(op) {
+    super(`cannot ${op} while in swap mode; run 'sgit track unswap' first.`);
+  }
+};
+var SwapModeCorruptError = class extends SgitError {
+  constructor(details) {
+    super(`shadow-git state is inconsistent:
+${details}`);
+  }
+};
+var InProgressGitOpError = class extends SgitError {
+  constructor(gitDir, marker) {
+    super(`cannot proceed: ${gitDir} has an in-progress operation (${marker}). Finish or abort it first.`);
+  }
+};
 
 // src/core/repository.ts
 async function findRoot() {
@@ -96,6 +136,12 @@ async function validateGitIdentity(root) {
 async function validateShadowRepo(root) {
   try {
     await access(join(root, ".sgit"), constants.F_OK);
+    return;
+  } catch {
+  }
+  try {
+    await access(join(root, ".git.sgit-parked"), constants.F_OK);
+    return;
   } catch {
     throw new NotInitializedError();
   }
@@ -119,9 +165,74 @@ async function validateNotSubmodule(root) {
 
 // src/commands/forward.ts
 import { spawnSync } from "child_process";
+
+// src/core/swap-mode.ts
+import { access as access2 } from "fs/promises";
+import { constants as constants2, existsSync } from "fs";
 import { join as join2 } from "path";
-function forwardToGit(root, args) {
-  const sgitDir = join2(root, ".sgit");
+var SWAP_MARKER = ".git.sgit-parked";
+async function pathExists(path) {
+  try {
+    await access2(path, constants2.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isSwapMode(root) {
+  return pathExists(join2(root, SWAP_MARKER));
+}
+function isSwapModeSync(root) {
+  return existsSync(join2(root, SWAP_MARKER));
+}
+async function resolveShadowDir(root) {
+  return await isSwapMode(root) ? join2(root, ".git") : join2(root, ".sgit");
+}
+async function resolveMainDir(root) {
+  return await isSwapMode(root) ? join2(root, SWAP_MARKER) : join2(root, ".git");
+}
+var IN_PROGRESS_MARKERS = [
+  "index.lock",
+  "MERGE_HEAD",
+  "CHERRY_PICK_HEAD",
+  "REVERT_HEAD",
+  "rebase-apply",
+  "rebase-merge",
+  "BISECT_LOG"
+];
+async function assertNoInProgressOps(gitDir) {
+  for (const marker of IN_PROGRESS_MARKERS) {
+    if (await pathExists(join2(gitDir, marker))) {
+      throw new InProgressGitOpError(gitDir, marker);
+    }
+  }
+}
+async function assertConsistentState(root) {
+  const hasDisabled = await pathExists(join2(root, SWAP_MARKER));
+  const hasGit = await pathExists(join2(root, ".git"));
+  const hasSgit = await pathExists(join2(root, ".sgit"));
+  if (hasDisabled && !hasGit) {
+    throw new SwapModeCorruptError(
+      [
+        `found ${SWAP_MARKER}/ but no .git/ \u2014 a swap-mode transition was interrupted.`,
+        hasSgit ? `to recover: rename ${SWAP_MARKER} back to .git (.sgit is still intact).` : `to recover: rename ${SWAP_MARKER} back to .git, or rename whichever of .sgit/${SWAP_MARKER} you want active to .git.`
+      ].join("\n")
+    );
+  }
+  if (hasDisabled && hasSgit) {
+    throw new SwapModeCorruptError(
+      [
+        `found both ${SWAP_MARKER}/ and .sgit/ \u2014 unexpected state.`,
+        "normally only one exists at a time.",
+        `investigate and remove the stale one before proceeding.`
+      ].join("\n")
+    );
+  }
+}
+
+// src/commands/forward.ts
+async function forwardToGit(root, args) {
+  const sgitDir = await resolveShadowDir(root);
   const result = spawnSync(
     "git",
     [`--git-dir=${sgitDir}`, `--work-tree=${root}`, ...args],
@@ -152,11 +263,32 @@ function error(msg) {
   process.stderr.write(`${RED}${msg}${RESET}
 `);
 }
+function swapModeBanner() {
+  const msg = [
+    "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+    "shadow-git is in SWAP MODE",
+    "main git is parked at .git.sgit-parked; .sgit is active at .git",
+    "this mode is for IDE/tool compatibility \u2014 read-only recommended",
+    "run 'sgit track unswap' before making main-repo changes",
+    "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"
+  ].join("\n");
+  process.stderr.write(`${YELLOW}${msg}${RESET}
+`);
+}
+function updateNotice(current, latest) {
+  const msg = [
+    `Update available: shadow-git ${current} \u2192 ${latest}`,
+    "Please run 'npm install -g shadow-git' to update."
+  ].join("\n");
+  process.stderr.write(`
+${CYAN}${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";
+import { mkdir as mkdir2, writeFile as writeFile3, readFile as readFile3, access as access4 } from "fs/promises";
+import { constants as constants4 } from "fs";
 
 // src/core/manifest.ts
 import { readFile, writeFile } from "fs/promises";
@@ -246,7 +378,7 @@ function generateMainExclude(existingContent, manifestPaths) {
   while (preserved.length > 0 && preserved[preserved.length - 1].trim() === "") {
     preserved.pop();
   }
-  const sgitEntries = [".sgit", ".sgit.json", ".gitignore-sgit.bat", ...manifestPaths];
+  const sgitEntries = [".sgit", ".sgit.json", ".git.sgit-parked", ".gitignore.sgit-parked", ...manifestPaths];
   return [
     ...preserved,
     "",
@@ -291,7 +423,7 @@ function generateShadowExclude(manifestPaths, ignorePaths = []) {
     "!.sgit.json",
     ...entryLines,
     ...ignorePaths,
-    ".gitignore-sgit.bat",
+    ".gitignore.sgit-parked",
     SGIT_BLOCK_END
   ].join("\n") + "\n";
 }
@@ -312,7 +444,7 @@ import {
   mkdir,
   writeFile as writeFile2,
   rename,
-  access as access2,
+  access as access3,
   lstat as lstat2,
   unlink,
   copyFile,
@@ -320,7 +452,7 @@ import {
   rm,
   readdir
 } from "fs/promises";
-import { constants as constants2 } from "fs";
+import { constants as constants3 } from "fs";
 var RUNNER_SCRIPT = `#!/bin/sh
 # sgit hook runner \u2014 executes all hooks in pre-commit.d/
 dir="$(dirname "$0")/pre-commit.d"
@@ -434,7 +566,7 @@ async function uninstallMainHook(root) {
 }
 async function exists(path) {
   try {
-    await access2(path, constants2.F_OK);
+    await access3(path, constants3.F_OK);
     return true;
   } catch {
     return false;
@@ -444,12 +576,15 @@ async function exists(path) {
 // src/commands/track/init.ts
 async function trackInit() {
   const root = await findRoot();
+  if (await isSwapMode(root)) {
+    throw new SwapModeActiveError("init");
+  }
   await validateNotWorktree(root);
   await validateNotSubmodule(root);
   await validateGitIdentity(root);
   const sgitDir = join5(root, ".sgit");
   try {
-    await access3(sgitDir, constants3.F_OK);
+    await access4(sgitDir, constants4.F_OK);
     throw new AlreadyInitializedError();
   } catch (err) {
     if (err instanceof AlreadyInitializedError) throw err;
@@ -501,28 +636,30 @@ async function trackInit() {
 
 // 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";
+import { writeFile as writeFile4, readFile as readFile4, mkdir as mkdir3, access as access5 } from "fs/promises";
+import { constants as constants5 } from "fs";
 async function syncExcludes(root) {
   const manifest = await readManifest(root);
-  const mainExcludePath = join6(root, ".git", "info", "exclude");
+  const mainDir = await resolveMainDir(root);
+  const shadowDir = await resolveShadowDir(root);
+  const mainExcludePath = join6(mainDir, "info", "exclude");
   let existingExclude = "";
   try {
     existingExclude = await readFile4(mainExcludePath, "utf-8");
   } catch {
   }
-  await mkdir3(join6(root, ".git", "info"), { recursive: true });
+  await mkdir3(join6(mainDir, "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 });
+  const sgitExcludePath = join6(shadowDir, "info", "exclude");
+  await mkdir3(join6(shadowDir, "info"), { recursive: true });
   await writeFile4(sgitExcludePath, generateShadowExclude(manifest.paths, manifest.ignore));
   for (const p of manifest.paths) {
     const checkPath = p.endsWith("/") ? p.slice(0, -1) : p;
     try {
-      await access4(join6(root, checkPath), constants4.F_OK);
+      await access5(join6(root, checkPath), constants5.F_OK);
     } catch {
       warn(`path does not exist: ${p}`);
     }
@@ -537,8 +674,8 @@ async function trackSync() {
 
 // src/commands/track/add.ts
 import { join as join7 } from "path";
-import { access as access5 } from "fs/promises";
-import { constants as constants5 } from "fs";
+import { access as access6 } from "fs/promises";
+import { constants as constants6 } from "fs";
 
 // src/core/paths.ts
 import { resolve as resolve2, relative, sep } from "path";
@@ -590,11 +727,12 @@ function isPathCoveredByManifest(filePath, manifestPaths, ignorePaths = []) {
 }
 
 // src/commands/track/add.ts
-var BLOCKED_BASENAMES = /* @__PURE__ */ new Set([".gitignore", ".gitignore-sgit.bat"]);
+var BLOCKED_BASENAMES = /* @__PURE__ */ new Set([".gitignore", ".gitignore.sgit-parked"]);
 async function trackAdd(paths, opts = {}) {
   const root = await findRoot();
   await validateShadowRepo(root);
-  const sgitDir = join7(root, ".sgit");
+  const sgitDir = await resolveShadowDir(root);
+  const mainDir = await resolveMainDir(root);
   const added = [];
   for (const inputPath of paths) {
     const normalized = await normalizePath(inputPath, root);
@@ -606,7 +744,7 @@ async function trackAdd(paths, opts = {}) {
     }
     const checkPath = normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
     try {
-      await access5(join7(root, checkPath), constants5.F_OK);
+      await access6(join7(root, checkPath), constants6.F_OK);
     } catch {
       throw new PathNotFoundError(normalized);
     }
@@ -615,7 +753,7 @@ async function trackAdd(paths, opts = {}) {
     let trackedByMain = false;
     try {
       await execGit(["ls-files", "--error-unmatch", checkPath], {
-        gitDir: join7(root, ".git"),
+        gitDir: mainDir,
         workTree: root
       });
       trackedByMain = true;
@@ -624,7 +762,7 @@ async function trackAdd(paths, opts = {}) {
     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 });
+        await execGit(rmArgs, { gitDir: mainDir, workTree: root });
       } else if (!opts.adopt) {
         throw new PathTrackedByMainError(normalized);
       }
@@ -653,11 +791,11 @@ async function trackAdd(paths, opts = {}) {
 }
 
 // src/commands/track/remove.ts
-import { join as join8, resolve as resolve3, relative as relative2, sep as sep2 } from "path";
+import { 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 sgitDir = await resolveShadowDir(root);
   const removed = [];
   for (const inputPath of paths) {
     const absolute = resolve3(process.cwd(), inputPath);
@@ -701,26 +839,46 @@ async function trackList() {
   return manifest.paths;
 }
 
-// src/commands/track/verify.ts
-import { join as join10 } from "path";
-
 // src/core/gitignore.ts
 import {
   readdirSync,
   renameSync,
-  existsSync,
+  existsSync as existsSync2,
   readFileSync,
   writeFileSync,
   unlinkSync
 } from "fs";
-import { join as join9, relative as relative3, sep as sep3 } from "path";
-var DISABLED_NAME = ".gitignore-sgit.bat";
+import { join as join8, relative as relative3, sep as sep3 } from "path";
+var DISABLED_NAME = ".gitignore.sgit-parked";
 var LOCK_FILE = ".gitignore-guard";
+function refuseIfSwapped(root, op) {
+  if (isSwapModeSync(root)) {
+    throw new SwapModeActiveError(op);
+  }
+}
+function disableGitignores(root, manifestPaths) {
+  refuseIfSwapped(root, "disable gitignores");
+  const gitignores = findInTrackedDirs(root, manifestPaths, ".gitignore");
+  if (gitignores.length === 0) return [];
+  const stale = findInTrackedDirs(root, manifestPaths, DISABLED_NAME);
+  if (stale.length > 0) {
+    throw new StaleGitignoreError(stale);
+  }
+  const disabled = [];
+  for (const relPath of gitignores) {
+    const absPath = join8(root, relPath);
+    const dir = absPath.substring(0, absPath.length - ".gitignore".length);
+    renameSync(absPath, dir + DISABLED_NAME);
+    disabled.push(relPath);
+  }
+  return disabled;
+}
 function enableGitignores(root, manifestPaths) {
+  refuseIfSwapped(root, "enable gitignores");
   const disabled = findInTrackedDirs(root, manifestPaths, DISABLED_NAME);
   const enabled = [];
   for (const relPath of disabled) {
-    const absPath = join9(root, relPath);
+    const absPath = join8(root, relPath);
     const restoredPath = absPath.substring(0, absPath.length - DISABLED_NAME.length) + ".gitignore";
     renameSync(absPath, restoredPath);
     enabled.push(relPath);
@@ -731,7 +889,7 @@ function findStaleGitignores(root, manifestPaths) {
   return findInTrackedDirs(root, manifestPaths, DISABLED_NAME);
 }
 function isGuardActive(root) {
-  const lockPath = join9(root, ".sgit", LOCK_FILE);
+  const lockPath = join8(root, ".sgit", LOCK_FILE);
   try {
     const pid = parseInt(readFileSync(lockPath, "utf-8").trim(), 10);
     if (isNaN(pid)) return false;
@@ -742,7 +900,8 @@ function isGuardActive(root) {
   }
 }
 function setupGitignoreGuard(root, manifestPaths) {
-  const lockPath = join9(root, ".sgit", LOCK_FILE);
+  refuseIfSwapped(root, "set up gitignore guard");
+  const lockPath = join8(root, ".sgit", LOCK_FILE);
   if (isGuardActive(root)) {
     return () => {
     };
@@ -750,7 +909,7 @@ function setupGitignoreGuard(root, manifestPaths) {
   const stale = findInTrackedDirs(root, manifestPaths, DISABLED_NAME);
   if (stale.length > 0) {
     warn(
-      "found stale .gitignore-sgit.bat files from a previous crash; restoring"
+      "found stale .gitignore.sgit-parked files from a previous crash; restoring"
     );
     enableGitignores(root, manifestPaths);
   }
@@ -761,7 +920,7 @@ function setupGitignoreGuard(root, manifestPaths) {
     };
   }
   for (const relPath of gitignores) {
-    const absPath = join9(root, relPath);
+    const absPath = join8(root, relPath);
     const dir = absPath.substring(0, absPath.length - ".gitignore".length);
     renameSync(absPath, dir + DISABLED_NAME);
   }
@@ -804,15 +963,15 @@ function findInTrackedDirs(root, manifestPaths, targetName) {
   const found = /* @__PURE__ */ new Set();
   for (const mPath of manifestPaths) {
     for (const ancestor of getAncestorDirs(mPath)) {
-      const dirAbs = ancestor === "" ? root : join9(root, ancestor);
-      const targetPath = join9(dirAbs, targetName);
-      if (existsSync(targetPath)) {
+      const dirAbs = ancestor === "" ? root : join8(root, ancestor);
+      const targetPath = join8(dirAbs, targetName);
+      if (existsSync2(targetPath)) {
         found.add(targetPath);
       }
     }
     if (mPath.endsWith("/")) {
-      const dirAbs = join9(root, mPath);
-      if (existsSync(dirAbs)) {
+      const dirAbs = join8(root, mPath);
+      if (existsSync2(dirAbs)) {
         walkSync(dirAbs, targetName, found);
       }
     }
@@ -840,7 +999,7 @@ function walkSync(dir, targetName, results) {
     if (entry.isDirectory() && (entry.name === ".git" || entry.name === ".sgit")) {
       continue;
     }
-    const fullPath = join9(dir, entry.name);
+    const fullPath = join8(dir, entry.name);
     if (entry.isDirectory()) {
       walkSync(fullPath, targetName, results);
     } else if (entry.name === targetName) {
@@ -859,17 +1018,17 @@ function cleanStaleLock(lockPath) {
 async function verifyMain(root) {
   const manifest = await readManifest(root);
   const violations = [];
-  if (!isGuardActive(root)) {
+  if (!isGuardActive(root) && !await isSwapMode(root)) {
     const stale = findStaleGitignores(root, manifest.paths);
     violations.push(
       ...stale.map(
-        (f) => `${f} (stale .gitignore-sgit.bat \u2014 rename back to .gitignore)`
+        (f) => `${f} (stale .gitignore.sgit-parked \u2014 rename back to .gitignore)`
       )
     );
   }
   try {
     const staged = await execGit(["diff", "--cached", "--name-only", "--diff-filter=ACMR"], {
-      gitDir: join10(root, ".git"),
+      gitDir: await resolveMainDir(root),
       workTree: root
     });
     if (staged.trim()) {
@@ -892,13 +1051,13 @@ async function verifyShadow(root) {
       violations: [".sgit.json (missing or invalid on disk)"]
     };
   }
-  const sgitDir = join10(root, ".sgit");
+  const sgitDir = await resolveShadowDir(root);
   const violations = [];
-  if (!isGuardActive(root)) {
+  if (!isGuardActive(root) && !await isSwapMode(root)) {
     const stale = findStaleGitignores(root, manifest.paths);
     violations.push(
       ...stale.map(
-        (f) => `${f} (stale .gitignore-sgit.bat \u2014 rename back to .gitignore)`
+        (f) => `${f} (stale .gitignore.sgit-parked \u2014 rename back to .gitignore)`
       )
     );
   }
@@ -987,19 +1146,22 @@ async function trackVerify(opts) {
 }
 
 // src/commands/track/clone.ts
-import { join as join11, extname } from "path";
-import { access as access6, readFile as readFile5, writeFile as writeFile5, rename as rename2, mkdir as mkdir4, rm as rm2 } from "fs/promises";
-import { constants as constants6 } from "fs";
+import { join as join9, extname } from "path";
+import { access as access7, readFile as readFile5, writeFile as writeFile5, rename as rename2, mkdir as mkdir4, rm as rm2 } from "fs/promises";
+import { constants as constants7 } from "fs";
 import { createInterface } from "readline";
 import { randomBytes } from "crypto";
 async function trackClone(url, opts = {}) {
   const root = await findRoot();
+  if (await isSwapMode(root)) {
+    throw new SwapModeActiveError("clone");
+  }
   await validateNotWorktree(root);
   await validateNotSubmodule(root);
   await validateGitIdentity(root);
-  const sgitDir = join11(root, ".sgit");
+  const sgitDir = join9(root, ".sgit");
   try {
-    await access6(sgitDir, constants6.F_OK);
+    await access7(sgitDir, constants7.F_OK);
     throw new AlreadyInitializedError();
   } catch (err) {
     if (err instanceof AlreadyInitializedError) throw err;
@@ -1015,6 +1177,11 @@ async function trackClone(url, opts = {}) {
   }
   await execGit(["config", "core.bare", "false"], { gitDir: sgitDir });
   await execGit(["config", "core.worktree", root], { gitDir: sgitDir });
+  await execGit(
+    ["config", "remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*"],
+    { gitDir: sgitDir }
+  );
+  await execGit(["fetch", "origin"], { gitDir: sgitDir });
   try {
     const name = await execGit(["config", "user.name"], { cwd: root });
     if (name) {
@@ -1047,7 +1214,7 @@ async function trackClone(url, opts = {}) {
   const conflicts = [];
   for (const file of trackedFiles) {
     try {
-      await access6(join11(root, file), constants6.F_OK);
+      await access7(join9(root, file), constants7.F_OK);
       conflicts.push(file);
     } catch {
     }
@@ -1066,19 +1233,19 @@ async function trackClone(url, opts = {}) {
     if (choice === 2) {
       const savedContent = /* @__PURE__ */ new Map();
       for (const file of conflicts) {
-        savedContent.set(file, await readFile5(join11(root, file)));
+        savedContent.set(file, await readFile5(join9(root, file)));
       }
       if (trackedFiles.length > 0) {
         await execGit(["checkout", "HEAD", "--", "."], { gitDir: sgitDir, workTree: root });
       }
       for (const [file, content] of savedContent) {
-        await mkdir4(join11(root, file, ".."), { recursive: true });
-        await writeFile5(join11(root, file), content);
+        await mkdir4(join9(root, file, ".."), { recursive: true });
+        await writeFile5(join9(root, file), content);
       }
     } else if (choice === 3) {
       for (const file of conflicts) {
         const renamed = generateOriginalName(file);
-        await rename2(join11(root, file), join11(root, renamed));
+        await rename2(join9(root, file), join9(root, renamed));
       }
       if (trackedFiles.length > 0) {
         await execGit(["checkout", "HEAD", "--", "."], { gitDir: sgitDir, workTree: root });
@@ -1146,13 +1313,16 @@ function generateOriginalName(filePath) {
 }
 
 // src/commands/track/destroy.ts
-import { join as join12, dirname as dirname2 } from "path";
+import { join as join10, dirname as dirname2 } from "path";
 import { readFile as readFile6, writeFile as writeFile6, rm as rm3, rmdir, unlink as unlink2 } from "fs/promises";
 import { createInterface as createInterface2 } from "readline";
 async function trackDestroy(opts) {
   const root = await findRoot();
+  if (await isSwapMode(root)) {
+    throw new SwapModeActiveError("destroy");
+  }
   await validateShadowRepo(root);
-  const sgitDir = join12(root, ".sgit");
+  const sgitDir = join10(root, ".sgit");
   let trackedFiles = [];
   try {
     const output = await execGit(["ls-tree", "-r", "--name-only", "HEAD"], {
@@ -1193,7 +1363,7 @@ async function trackDestroy(opts) {
       return;
     }
   }
-  const excludePath = join12(root, ".git", "info", "exclude");
+  const excludePath = join10(root, ".git", "info", "exclude");
   try {
     const content = await readFile6(excludePath, "utf-8");
     const lines = content.split("\n");
@@ -1229,7 +1399,7 @@ async function trackDestroy(opts) {
   if (!opts.keepFiles && trackedFiles.length > 0) {
     for (const file of trackedFiles) {
       try {
-        await unlink2(join12(root, file));
+        await unlink2(join10(root, file));
       } catch {
       }
     }
@@ -1244,13 +1414,13 @@ async function trackDestroy(opts) {
     const sortedDirs = [...dirs].sort((a, b) => b.length - a.length);
     for (const dir of sortedDirs) {
       try {
-        await rmdir(join12(root, dir));
+        await rmdir(join10(root, dir));
       } catch {
       }
     }
   }
-  await rm3(join12(root, ".sgit"), { recursive: true, force: true });
-  await rm3(join12(root, ".sgit.json"), { force: true });
+  await rm3(join10(root, ".sgit"), { recursive: true, force: true });
+  await rm3(join10(root, ".sgit.json"), { force: true });
   if (opts.keepFiles) {
     success("Shadow repository removed. Tracked files kept on disk.");
   } else {
@@ -1271,11 +1441,10 @@ async function confirm(message) {
 }
 
 // src/commands/track/ignore.ts
-import { join as join13 } from "path";
 async function trackIgnore(paths) {
   const root = await findRoot();
   await validateShadowRepo(root);
-  const sgitDir = join13(root, ".sgit");
+  const sgitDir = await resolveShadowDir(root);
   const added = [];
   for (const inputPath of paths) {
     const normalized = await normalizePath(inputPath, root);
@@ -1337,7 +1506,7 @@ async function trackUnignore(paths) {
 }
 
 // src/commands/track/completion.ts
-import { join as join14, dirname as dirname3 } from "path";
+import { join as join11, dirname as dirname3 } from "path";
 import { mkdir as mkdir5, writeFile as writeFile7 } from "fs/promises";
 import { homedir } from "os";
 function bashCompletion() {
@@ -1566,11 +1735,11 @@ function getInstallPath(shell) {
   const home = homedir();
   switch (shell) {
     case "zsh":
-      return join14(home, ".zsh", "completions", "_sgit");
+      return join11(home, ".zsh", "completions", "_sgit");
     case "fish":
-      return join14(home, ".config", "fish", "completions", "sgit.fish");
+      return join11(home, ".config", "fish", "completions", "sgit.fish");
     default:
-      return join14(home, ".local", "share", "bash-completion", "completions", "sgit");
+      return join11(home, ".local", "share", "bash-completion", "completions", "sgit");
   }
 }
 async function trackCompletion(action, opts) {
@@ -1596,6 +1765,76 @@ async function trackCompletion(action, opts) {
   process.exit(1);
 }
 
+// src/commands/track/swap.ts
+import { join as join12 } from "path";
+import { rename as rename3 } from "fs/promises";
+async function trackSwap() {
+  const root = await findRoot();
+  await validateShadowRepo(root);
+  if (await isSwapMode(root)) {
+    throw new AlreadySwappedError();
+  }
+  await assertNoInProgressOps(join12(root, ".git"));
+  const manifest = await readManifest(root);
+  const gitPath = join12(root, ".git");
+  const sgitPath = join12(root, ".sgit");
+  const disabledPath = join12(root, SWAP_MARKER);
+  disableGitignores(root, manifest.paths);
+  let gitRenamed = false;
+  try {
+    await rename3(gitPath, disabledPath);
+    gitRenamed = true;
+    await rename3(sgitPath, gitPath);
+  } catch (err) {
+    if (gitRenamed) {
+      try {
+        await rename3(disabledPath, gitPath);
+      } catch {
+      }
+    }
+    try {
+      enableGitignores(root, manifest.paths);
+    } catch {
+    }
+    throw err;
+  }
+  success(
+    "Swap mode enabled. .sgit is now .git; main git is parked at .git.sgit-parked."
+  );
+  info("Run 'sgit track unswap' to exit.");
+}
+
+// src/commands/track/unswap.ts
+import { join as join13 } from "path";
+import { rename as rename4 } from "fs/promises";
+async function trackUnswap() {
+  const root = await findRoot();
+  if (!await isSwapMode(root)) {
+    throw new NotSwappedError();
+  }
+  const gitPath = join13(root, ".git");
+  const sgitPath = join13(root, ".sgit");
+  const disabledPath = join13(root, SWAP_MARKER);
+  await assertNoInProgressOps(gitPath);
+  let shadowRenamed = false;
+  try {
+    await rename4(gitPath, sgitPath);
+    shadowRenamed = true;
+    await rename4(disabledPath, gitPath);
+  } catch (err) {
+    if (shadowRenamed) {
+      try {
+        await rename4(sgitPath, gitPath);
+      } catch {
+      }
+    }
+    throw err;
+  }
+  const manifest = await readManifest(root);
+  enableGitignores(root, manifest.paths);
+  success("Swap mode disabled. Main git restored.");
+}
+
 // src/commands/track/index.ts
 function registerTrackCommands(program) {
   const track = program.command("track").description("Manage shadow-tracked paths");
@@ -1622,6 +1861,8 @@ function registerTrackCommands(program) {
       async (action, opts) => trackCompletion(action, opts)
     )
   );
+  track.command("swap").description("Swap .git with .sgit so IDE tools see the shadow repo as the active git").action(wrapAction(trackSwap));
+  track.command("unswap").description("Exit swap mode and restore the main repository").action(wrapAction(trackUnswap));
 }
 function wrapAction(fn) {
   return async (...args) => {
@@ -1682,11 +1923,191 @@ function wrapAction2(fn) {
   };
 }
 
+// src/core/update-check.ts
+import { spawn } from "child_process";
+import {
+  mkdirSync,
+  readFileSync as readFileSync2,
+  statSync,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { homedir as homedir2 } from "os";
+import { isAbsolute, join as join14 } from "path";
+var PACKAGE_NAME = "shadow-git";
+var DIST_TAGS_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/dist-tags`;
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 1e4;
+var LOCK_STALE_MS = 6e4;
+var STATE_FILE = "update-check.json";
+var LOCK_FILE2 = "update-check.lock";
+var VERSION_RE = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+var UPDATE_CHECK_ARG = "__update-check";
+var HANDLED_ENV = "SGIT_UPDATE_NOTICE_HANDLED";
+function setupUpdateNotifier(currentVersion, entry, args) {
+  const nested = Boolean(process.env[HANDLED_ENV]);
+  process.env[HANDLED_ENV] = "1";
+  if (nested || !isEnabled(args)) return;
+  try {
+    const dir = getCacheDir();
+    if (isCheckDue(readState(dir)) && acquireLock(dir)) {
+      spawnWorker(dir, entry);
+    }
+    process.on("exit", () => showNotice(dir, currentVersion));
+  } catch {
+  }
+}
+async function runUpdateCheckWorker() {
+  try {
+    const dir = getCacheDir();
+    try {
+      const latest = await fetchLatestVersion();
+      if (latest !== void 0) {
+        writeState(dir, { checkedAt: Date.now(), latest });
+      }
+    } finally {
+      releaseLock(dir);
+    }
+  } catch {
+  }
+}
+function isNewerVersion(latest, current) {
+  const a = VERSION_RE.exec(latest);
+  const b = VERSION_RE.exec(current);
+  if (!a || !b) return false;
+  for (let i = 1; i <= 3; i++) {
+    const diff = Number(a[i]) - Number(b[i]);
+    if (diff !== 0) return diff > 0;
+  }
+  return a[4] === void 0 && b[4] !== void 0;
+}
+function getCacheDir() {
+  const xdg = process.env.XDG_CACHE_HOME;
+  const base = xdg && isAbsolute(xdg) ? xdg : join14(homedir2(), ".cache");
+  return join14(base, PACKAGE_NAME);
+}
+function isEnabled(args) {
+  if (!process.stdout.isTTY || !process.stderr.isTTY) return false;
+  if (process.env.NO_UPDATE_NOTIFIER) return false;
+  if (args[0] === "track" && args[1] === "verify") return false;
+  return true;
+}
+function isCheckDue(state) {
+  if (!state) return true;
+  const age = Date.now() - state.checkedAt;
+  return age < 0 || age >= DAY_MS;
+}
+function showNotice(dir, currentVersion) {
+  try {
+    const latest = readState(dir)?.latest;
+    if (latest !== void 0 && isNewerVersion(latest, currentVersion)) {
+      updateNotice(currentVersion, latest);
+    }
+  } catch {
+  }
+}
+function spawnWorker(dir, entry) {
+  try {
+    const child = spawn(process.execPath, [entry, UPDATE_CHECK_ARG], {
+      cwd: dir,
+      // not the user's repo — a lingering cwd can block deleting it
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true
+    });
+    child.on("error", () => releaseLock(dir));
+    child.unref();
+  } catch {
+    releaseLock(dir);
+  }
+}
+async function fetchLatestVersion() {
+  const res = await fetch(DIST_TAGS_URL, {
+    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+  });
+  if (!res.ok) return void 0;
+  const tags = await res.json();
+  return typeof tags?.latest === "string" ? tags.latest : void 0;
+}
+function readState(dir) {
+  try {
+    const data = JSON.parse(
+      readFileSync2(join14(dir, STATE_FILE), "utf-8")
+    );
+    if (typeof data?.checkedAt !== "number" || typeof data.latest !== "string") {
+      return void 0;
+    }
+    return { checkedAt: data.checkedAt, latest: data.latest };
+  } catch {
+    return void 0;
+  }
+}
+function writeState(dir, state) {
+  writeFileSync2(join14(dir, STATE_FILE), JSON.stringify(state, null, 2) + "\n");
+}
+function acquireLock(dir) {
+  const lockPath = join14(dir, LOCK_FILE2);
+  try {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync2(lockPath, String(process.pid), { flag: "wx" });
+    return true;
+  } catch {
+  }
+  try {
+    const age = Math.abs(Date.now() - statSync(lockPath).mtimeMs);
+    if (age < LOCK_STALE_MS) return false;
+    writeFileSync2(lockPath, String(process.pid));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function releaseLock(dir) {
+  try {
+    unlinkSync2(join14(dir, LOCK_FILE2));
+  } catch {
+  }
+}
+
 // src/cli.ts
 var COMMANDER_COMMANDS = /* @__PURE__ */ new Set(["track", "debug"]);
+function readVersion() {
+  try {
+    const pkg = JSON.parse(
+      readFileSync3(new URL("../package.json", import.meta.url), "utf-8")
+    );
+    return typeof pkg.version === "string" ? pkg.version : void 0;
+  } catch {
+    return void 0;
+  }
+}
 async function run() {
   const args = process.argv.slice(2);
-  const skipGuard = args[0] === "track" && (args[1] === "init" || args[1] === "clone") || args[0] === "debug";
+  if (args[0] === UPDATE_CHECK_ARG) {
+    await runUpdateCheckWorker();
+    process.exit(0);
+  }
+  const version = readVersion();
+  if (version) {
+    setupUpdateNotifier(version, fileURLToPath(import.meta.url), args);
+  }
+  let swapActive = false;
+  try {
+    const root = await findRoot();
+    await assertConsistentState(root);
+    swapActive = await isSwapMode(root);
+  } catch (err) {
+    if (err instanceof SwapModeCorruptError) {
+      error(err.message);
+      process.exit(1);
+    }
+  }
+  const suppressBanner = args[0] === "track" && (args[1] === "swap" || args[1] === "unswap");
+  if (swapActive && !suppressBanner) {
+    swapModeBanner();
+  }
+  const selfManagedGuard = args[0] === "track" && (args[1] === "init" || args[1] === "clone" || args[1] === "swap" || args[1] === "unswap");
+  const skipGuard = selfManagedGuard || args[0] === "debug" || swapActive;
   let guardCleanup;
   if (!skipGuard) {
     try {
@@ -1698,7 +2119,7 @@ async function run() {
   }
   try {
     if (args.length === 0 || COMMANDER_COMMANDS.has(args[0]) || args[0].startsWith("-")) {
-      const program = new Command2("sgit").description("Shadow Git \u2014 a secondary git repository for your project").version("0.1.0");
+      const program = new Command2("sgit").description("Shadow Git \u2014 a secondary git repository for your project").version(version ?? "unknown");
       registerTrackCommands(program);
       registerDebugCommands(program);
       program.addHelpText(
@@ -1714,6 +2135,8 @@ Track commands:
   sgit track unignore      Stop ignoring paths
   sgit track sync          Regenerate exclude files
   sgit track verify        Validate staged files
+  sgit track swap          Swap .git with .sgit for IDE compatibility
+  sgit track unswap        Exit swap mode
   sgit track destroy       Remove shadow repository
   sgit track completion    Install shell completions
 
@@ -1724,7 +2147,7 @@ All other commands are forwarded to git in the shadow repository:
     } else {
       const root = await findRoot();
       await validateShadowRepo(root);
-      const exitCode = forwardToGit(root, args);
+      const exitCode = await forwardToGit(root, args);
       guardCleanup?.();
       guardCleanup = void 0;
       process.exit(exitCode);