@shivanshshrivas/gwit 0.2.1 → 0.2.3

package/README.md

@@ -1,12 +1,12 @@
-# gwit
-
-[![npm version](https://img.shields.io/npm/v/%40shivanshshrivas%2Fgwit)](https://www.npmjs.com/package/@shivanshshrivas/gwit)
-[![npm downloads](https://img.shields.io/npm/dm/%40shivanshshrivas%2Fgwit)](https://www.npmjs.com/package/@shivanshshrivas/gwit)
-[![CI](https://github.com/shivanshshrivas/gwit/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/shivanshshrivas/gwit/actions/workflows/ci.yml)
-[![Node >=20](https://img.shields.io/badge/node-%3E%3D20-339933)](https://nodejs.org/)
-[![License: MIT](https://img.shields.io/badge/license-MIT-yellow.svg)](./LICENSE)
-
-Fully isolated git worktrees, in one command.
+# gwit
+
+[![npm version](https://img.shields.io/npm/v/%40shivanshshrivas%2Fgwit)](https://www.npmjs.com/package/@shivanshshrivas/gwit)
+[![npm downloads](https://img.shields.io/npm/dm/%40shivanshshrivas%2Fgwit)](https://www.npmjs.com/package/@shivanshshrivas/gwit)
+[![CI](https://github.com/shivanshshrivas/gwit/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/shivanshshrivas/gwit/actions/workflows/ci.yml)
+[![Node >=20](https://img.shields.io/badge/node-%3E%3D20-339933)](https://nodejs.org/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-yellow.svg)](./LICENSE)
+
+Fully isolated git worktrees, in one command.
 
 gwit wraps `git worktree` to turn a fresh checkout into a fully working environment - gitignored files copied, unique port assigned, per-worktree env vars injected, and setup scripts run automatically.
 
@@ -134,6 +134,9 @@ gwit sync --back               # auto-detect branch, then merge back
 If both sides changed different text regions, gwit applies a clean merge.  
 If both sides changed the same region, gwit writes git-style conflict markers  
 (`<<<<<<<`, `=======`, `>>>>>>>`). Binary conflicts are skipped with a warning.
+Files currently matched by `.gwitinclude` but not present in the snapshot
+(for example, new files created later inside an included ignored directory)
+are reverse-copied directly from worktree to main.
 
 ### `gwit open <branch>`
 

package/dist/index.cjs

@@ -437,11 +437,67 @@ function expandGlob(pattern, cwd) {
   const files = result.stdout.split("\n").filter((f) => f.length > 0);
   return files.filter((f) => (0, import_minimatch.minimatch)(f, pattern, { dot: true }));
 }
+function normalizeRelPath(relPath) {
+  return relPath.replace(/\\/g, "/");
+}
+function resolveLiteralEntryFiles(entry, sourcePath) {
+  const entryPath = entry.replace(/\/$/, "");
+  if (entryPath.length === 0) return [];
+  if (path2.isAbsolute(entryPath)) return [];
+  const sourceResolved = path2.resolve(sourcePath);
+  const resolvedEntry = path2.resolve(sourcePath, entryPath);
+  const relToSource = path2.relative(sourceResolved, resolvedEntry);
+  if (relToSource.startsWith("..") || path2.isAbsolute(relToSource)) return [];
+  if (!fs2.existsSync(resolvedEntry)) return [];
+  const stat = fs2.statSync(resolvedEntry);
+  if (stat.isFile()) {
+    return [normalizeRelPath(relToSource)];
+  }
+  if (!stat.isDirectory()) return [];
+  const files = [];
+  const stack = [resolvedEntry];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) continue;
+    const entries = fs2.readdirSync(current, { withFileTypes: true });
+    for (const dirent of entries) {
+      const childPath = path2.join(current, dirent.name);
+      if (dirent.isDirectory()) {
+        stack.push(childPath);
+        continue;
+      }
+      if (dirent.isFile()) {
+        const rel = path2.relative(sourceResolved, childPath);
+        if (!rel.startsWith("..") && !path2.isAbsolute(rel)) {
+          files.push(normalizeRelPath(rel));
+        }
+      }
+    }
+  }
+  return files;
+}
 function parseGwitInclude(mainPath) {
   const includePath = path2.join(mainPath, GWITINCLUDE_FILE);
   if (!fs2.existsSync(includePath)) return [];
   return _parseLines(fs2.readFileSync(includePath, "utf-8"));
 }
+function resolveIncludedFilePaths(mainPath, sourcePath) {
+  const rawEntries = parseGwitInclude(mainPath);
+  if (rawEntries.length === 0) return [];
+  const files = /* @__PURE__ */ new Set();
+  for (const entry of rawEntries) {
+    if (isGlobPattern(entry)) {
+      for (const match of expandGlob(entry, sourcePath)) {
+        files.add(normalizeRelPath(match));
+      }
+      continue;
+    }
+    for (const relPath of resolveLiteralEntryFiles(entry, sourcePath)) {
+      files.add(relPath);
+    }
+  }
+  return [...files].sort();
+}
 function copyIncludedFiles(mainPath, worktreePath) {
   const rawEntries = parseGwitInclude(mainPath);
   if (rawEntries.length === 0) return [];
@@ -537,7 +593,7 @@ var path3 = __toESM(require("path"));
 var import_crypto = require("crypto");
 var FILES_DIR_NAME = "files";
 var MANIFEST_FILE_NAME = "manifest.json";
-function normalizeRelPath(relPath) {
+function normalizeRelPath2(relPath) {
   return relPath.replace(/\\/g, "/");
 }
 function tryChmod(filePath, mode) {
@@ -565,7 +621,7 @@ function collectEntryFiles(entryPath, mainPath) {
   }
   const stat = fs3.statSync(resolvedEntry);
   if (stat.isFile()) {
-    return [normalizeRelPath(relToMain)];
+    return [normalizeRelPath2(relToMain)];
   }
   const files = [];
   const stack = [resolvedEntry];
@@ -582,7 +638,7 @@ function collectEntryFiles(entryPath, mainPath) {
       if (entry.isFile()) {
         const rel = path3.relative(resolvedMain, childPath);
         if (!rel.startsWith("..") && !path3.isAbsolute(rel)) {
-          files.push(normalizeRelPath(rel));
+          files.push(normalizeRelPath2(rel));
         }
       }
     }
@@ -1421,7 +1477,7 @@ var fs9 = __toESM(require("fs"));
 // src/core/merge.ts
 var fs8 = __toESM(require("fs"));
 var path7 = __toESM(require("path"));
-function normalizeRelPath2(relPath) {
+function normalizeRelPath3(relPath) {
   return relPath.replace(/\\/g, "/");
 }
 function copyFileToMain(worktreeFile, mainFile) {
@@ -1459,6 +1515,73 @@ function runGitMergeFile(mainFile, snapshotFile, worktreeFile, branch) {
   ]);
   return result.exitCode > 0;
 }
+function isInMergeScope(relPath, mainPath) {
+  return isGitIgnored(relPath, mainPath) && !isGitTracked(relPath, mainPath);
+}
+function processSnapshotTrackedFile(result, relPath, worktreePath, mainPath, slug, branch, baseHash) {
+  if (!isInMergeScope(relPath, mainPath)) {
+    result.skipped.push(relPath);
+    return;
+  }
+  const mainFile = path7.resolve(mainPath, relPath);
+  const worktreeFile = path7.resolve(worktreePath, relPath);
+  const snapshotFile = getSnapshotFilePath(slug, relPath);
+  if (!isExistingFile(mainFile)) {
+    result.skipped.push(relPath);
+    return;
+  }
+  if (!isExistingFile(worktreeFile)) {
+    result.skipped.push(relPath);
+    return;
+  }
+  if (!snapshotFile || !isExistingFile(snapshotFile)) {
+    result.skipped.push(relPath);
+    return;
+  }
+  const mainHash = hashFile(mainFile);
+  const worktreeHash = hashFile(worktreeFile);
+  if (baseHash === mainHash && baseHash === worktreeHash) {
+    result.skipped.push(relPath);
+    return;
+  }
+  if (baseHash === mainHash) {
+    copyFileToMain(worktreeFile, mainFile);
+    result.copied.push(relPath);
+    return;
+  }
+  if (baseHash === worktreeHash || mainHash === worktreeHash) {
+    result.skipped.push(relPath);
+    return;
+  }
+  if (isBinaryFile(mainFile) || isBinaryFile(worktreeFile) || isBinaryFile(snapshotFile)) {
+    result.binarySkipped.push(relPath);
+    return;
+  }
+  const hasConflicts = runGitMergeFile(mainFile, snapshotFile, worktreeFile, branch);
+  if (hasConflicts) {
+    result.conflicts.push(relPath);
+    return;
+  }
+  result.merged.push(relPath);
+}
+function processNonSnapshotIncludeFile(result, relPath, worktreePath, mainPath) {
+  if (!isInMergeScope(relPath, mainPath)) {
+    result.skipped.push(relPath);
+    return;
+  }
+  const worktreeFile = path7.resolve(worktreePath, relPath);
+  if (!isExistingFile(worktreeFile)) {
+    result.skipped.push(relPath);
+    return;
+  }
+  const mainFile = path7.resolve(mainPath, relPath);
+  if (isExistingFile(mainFile) && hashFile(mainFile) === hashFile(worktreeFile)) {
+    result.skipped.push(relPath);
+    return;
+  }
+  copyFileToMain(worktreeFile, mainFile);
+  result.copied.push(relPath);
+}
 function mergeBackIncludedFiles(worktreePath, mainPath, slug) {
   const result = {
     copied: [],
@@ -1469,59 +1592,29 @@ function mergeBackIncludedFiles(worktreePath, mainPath, slug) {
   };
   const manifest = readSnapshot(slug);
   if (!manifest) return result;
-  const relPaths = Object.keys(manifest.files).sort();
-  for (const rawRelPath of relPaths) {
-    const relPath = normalizeRelPath2(rawRelPath);
-    const base = manifest.files[relPath];
+  const snapshotEntries = Object.keys(manifest.files).sort();
+  const snapshotRelPathSet = new Set(snapshotEntries.map((relPath) => normalizeRelPath3(relPath)));
+  for (const rawRelPath of snapshotEntries) {
+    const relPath = normalizeRelPath3(rawRelPath);
+    const base = manifest.files[rawRelPath];
     if (!base) {
       result.skipped.push(relPath);
       continue;
     }
-    if (!isGitIgnored(relPath, mainPath) || isGitTracked(relPath, mainPath)) {
-      result.skipped.push(relPath);
-      continue;
-    }
-    const mainFile = path7.resolve(mainPath, relPath);
-    const worktreeFile = path7.resolve(worktreePath, relPath);
-    const snapshotFile = getSnapshotFilePath(slug, relPath);
-    if (!isExistingFile(mainFile)) {
-      result.skipped.push(relPath);
-      continue;
-    }
-    if (!isExistingFile(worktreeFile)) {
-      result.skipped.push(relPath);
-      continue;
-    }
-    if (!snapshotFile || !isExistingFile(snapshotFile)) {
-      result.skipped.push(relPath);
-      continue;
-    }
-    const baseHash = base.hash;
-    const mainHash = hashFile(mainFile);
-    const worktreeHash = hashFile(worktreeFile);
-    if (baseHash === mainHash && baseHash === worktreeHash) {
-      result.skipped.push(relPath);
-      continue;
-    }
-    if (baseHash === mainHash) {
-      copyFileToMain(worktreeFile, mainFile);
-      result.copied.push(relPath);
-      continue;
-    }
-    if (baseHash === worktreeHash || mainHash === worktreeHash) {
-      result.skipped.push(relPath);
-      continue;
-    }
-    if (isBinaryFile(mainFile) || isBinaryFile(worktreeFile) || isBinaryFile(snapshotFile)) {
-      result.binarySkipped.push(relPath);
-      continue;
-    }
-    const hasConflicts = runGitMergeFile(mainFile, snapshotFile, worktreeFile, manifest.branch);
-    if (hasConflicts) {
-      result.conflicts.push(relPath);
-    } else {
-      result.merged.push(relPath);
-    }
+    processSnapshotTrackedFile(
+      result,
+      relPath,
+      worktreePath,
+      mainPath,
+      slug,
+      manifest.branch,
+      base.hash
+    );
+  }
+  const includeFiles = resolveIncludedFilePaths(mainPath, worktreePath);
+  for (const relPath of includeFiles) {
+    if (snapshotRelPathSet.has(relPath)) continue;
+    processNonSnapshotIncludeFile(result, relPath, worktreePath, mainPath);
   }
   return result;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shivanshshrivas/gwit",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Fully isolated git worktrees for parallel development",
   "keywords": [
     "git",
@@ -24,9 +24,10 @@
   "files": [
     "dist"
   ],
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsx src/index.ts",
+  "scripts": {
+    "build": "tsup",
+    "prepack": "npm run build",
+    "dev": "tsx src/index.ts",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",