stackpatch 1.1.0 → 1.1.1

package/bin/stackpatch.ts

@@ -303,53 +303,56 @@ async function copyFiles(src: string, dest: string): Promise<{ success: boolean;
     }
   }
 
+  // Track files from SOURCE (boilerplate) before copying
+  // This ensures we only track files that are actually from StackPatch
+  function trackSourceFiles(srcDir: string, baseDir: string, targetBase: string): void {
+    if (!fs.existsSync(srcDir)) return;
+
+    const files = fs.readdirSync(srcDir, { withFileTypes: true });
+    for (const file of files) {
+      const srcFilePath = path.join(srcDir, file.name);
+      if (file.isDirectory()) {
+        trackSourceFiles(srcFilePath, baseDir, targetBase);
+      } else {
+        const relativePath = path.relative(baseDir, srcFilePath);
+        const targetPath = targetBase
+          ? path.join(targetBase, relativePath).replace(/\\/g, "/")
+          : relativePath.replace(/\\/g, "/");
+        addedFiles.push(targetPath);
+      }
+    }
+  }
+
   // Copy files with smart app directory handling
   for (const entry of entries) {
     const srcPath = path.join(src, entry.name);
 
     if (entry.name === "app") {
+      // Track files from SOURCE boilerplate before copying
+      trackSourceFiles(srcPath, srcPath, appDir);
+
       // Copy app directory contents to the detected app directory location
       await fse.ensureDir(appDirPath);
       await fse.copy(srcPath, appDirPath, { overwrite: true });
-
-      // Track all files in app directory
-      function trackFiles(dir: string, baseDir: string) {
-        const files = fs.readdirSync(dir, { withFileTypes: true });
-        for (const file of files) {
-          const filePath = path.join(dir, file.name);
-          if (file.isDirectory()) {
-            trackFiles(filePath, baseDir);
-          } else {
-            const relativePath = path.relative(baseDir, filePath);
-            addedFiles.push(path.join(appDir, relativePath).replace(/\\/g, "/"));
-          }
-        }
-      }
-      trackFiles(appDirPath, appDirPath);
     } else if (entry.name === "components") {
+      // Track files from SOURCE boilerplate before copying
+      trackSourceFiles(srcPath, srcPath, componentsDir);
+
       // Copy components directory to the detected components directory location
       await fse.ensureDir(componentsDirPath);
       await fse.copy(srcPath, componentsDirPath, { overwrite: true });
-
-      // Track all files in components directory
-      function trackFiles(dir: string, baseDir: string) {
-        const files = fs.readdirSync(dir, { withFileTypes: true });
-        for (const file of files) {
-          const filePath = path.join(dir, file.name);
-          if (file.isDirectory()) {
-            trackFiles(filePath, baseDir);
-          } else {
-            const relativePath = path.relative(baseDir, filePath);
-            addedFiles.push(path.join(componentsDir, relativePath).replace(/\\/g, "/"));
-          }
-        }
-      }
-      trackFiles(componentsDirPath, componentsDirPath);
     } else {
+      // For root-level files/directories, track from source
+      const srcStat = fs.statSync(srcPath);
+      if (srcStat.isDirectory()) {
+        trackSourceFiles(srcPath, srcPath, "");
+      } else {
+        addedFiles.push(entry.name);
+      }
+
       // Copy other files/directories (middleware, etc.) to root
       const destPath = path.join(dest, entry.name);
       await fse.copy(srcPath, destPath, { overwrite: true });
-      addedFiles.push(entry.name);
     }
   }
 
@@ -1790,9 +1793,66 @@ async function main() {
     let failedRestorations: string[] = [];
     const directoriesToCheck: Set<string> = new Set();
 
-    // Step 1: Remove added files
+    // Step 1: Get list of valid StackPatch files from boilerplate
+    // This ensures we only remove files that are actually from StackPatch
+    const boilerplatePath = path.join(BOILERPLATE_ROOT, manifest.patchName === "auth-ui" ? "auth" : manifest.patchName);
+    const validStackPatchFiles = new Set<string>();
+
+    function collectBoilerplateFiles(srcDir: string, baseDir: string, targetBase: string): void {
+      if (!fs.existsSync(srcDir)) return;
+
+      const files = fs.readdirSync(srcDir, { withFileTypes: true });
+      for (const file of files) {
+        const srcFilePath = path.join(srcDir, file.name);
+        if (file.isDirectory()) {
+          collectBoilerplateFiles(srcFilePath, baseDir, targetBase);
+        } else {
+          const relativePath = path.relative(baseDir, srcFilePath);
+          const targetPath = targetBase
+            ? path.join(targetBase, relativePath).replace(/\\/g, "/")
+            : relativePath.replace(/\\/g, "/");
+          validStackPatchFiles.add(targetPath);
+        }
+      }
+    }
+
+    // Collect files from boilerplate app directory
+    const appDir = detectAppDirectory(target);
+    const componentsDir = detectComponentsDirectory(target);
+    const boilerplateAppPath = path.join(boilerplatePath, "app");
+    const boilerplateComponentsPath = path.join(boilerplatePath, "components");
+
+    if (fs.existsSync(boilerplateAppPath)) {
+      collectBoilerplateFiles(boilerplateAppPath, boilerplateAppPath, appDir);
+    }
+    if (fs.existsSync(boilerplateComponentsPath)) {
+      collectBoilerplateFiles(boilerplateComponentsPath, boilerplateComponentsPath, componentsDir);
+    }
+
+    // Collect root-level files
+    if (fs.existsSync(boilerplatePath)) {
+      const entries = fs.readdirSync(boilerplatePath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name !== "app" && entry.name !== "components") {
+          const srcPath = path.join(boilerplatePath, entry.name);
+          if (entry.isDirectory()) {
+            collectBoilerplateFiles(srcPath, srcPath, "");
+          } else {
+            validStackPatchFiles.add(entry.name);
+          }
+        }
+      }
+    }
+
+    // Step 1: Remove added files (only if they're actually from StackPatch boilerplate)
     console.log(chalk.white("📁 Removing added files..."));
     for (const filePath of manifest.files.added) {
+      // Only remove if this file is actually in the boilerplate
+      if (!validStackPatchFiles.has(filePath)) {
+        console.log(chalk.gray(`   ⊘ Skipped (not in boilerplate): ${filePath}`));
+        continue;
+      }
+
       const fullPath = path.join(target, filePath);
       if (fs.existsSync(fullPath)) {
         try {
@@ -1884,23 +1944,33 @@ async function main() {
       }
     }
 
-    // Step 5: Clean up empty directories
+    // Step 5: Clean up empty directories (only if they only contained StackPatch files)
     console.log(chalk.white("\n🧹 Cleaning up empty directories..."));
     const sortedDirs = Array.from(directoriesToCheck).sort((a, b) => b.length - a.length); // Sort by depth (deepest first)
+    let removedDirCount = 0;
+
     for (const dir of sortedDirs) {
       if (fs.existsSync(dir)) {
         try {
           const entries = fs.readdirSync(dir);
           if (entries.length === 0) {
+            // Only remove if directory is empty
+            // We know it was created by StackPatch because we're tracking it
             fs.rmdirSync(dir);
+            removedDirCount++;
             console.log(chalk.green(`   ✓ Removed empty directory: ${path.relative(target, dir)}`));
           }
+          // If directory has other files, we don't remove it (silently skip)
         } catch {
           // Ignore errors
         }
       }
     }
 
+    if (removedDirCount === 0) {
+      console.log(chalk.gray("   ⊘ No empty directories to remove"));
+    }
+
     // Step 6: Remove manifest and backups
     console.log(chalk.white("\n🗑️  Removing StackPatch tracking files..."));
     const stackpatchDir = path.join(target, ".stackpatch");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stackpatch",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Composable frontend features for modern React & Next.js apps - Add authentication, UI components, and more with zero configuration",
   "main": "bin/stackpatch.ts",
   "type": "module",