stackpatch 1.1.0 → 1.1.2

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 {
@@ -1851,24 +1911,95 @@ async function main() {
       }
     }
 
-    // Step 3: Restore modified files from backups
+    // Step 3: Restore modified files from originalContent in manifest
+    // This is more reliable than backups since it contains the true original content
     console.log(chalk.white("\n📝 Restoring modified files..."));
     for (const modified of manifest.files.modified) {
-      const backupPath = path.join(target, ".stackpatch", "backups", modified.path.replace(/\//g, "_").replace(/\\/g, "_"));
       const originalPath = path.join(target, modified.path);
 
-      if (fs.existsSync(backupPath)) {
+      if (modified.originalContent !== undefined) {
         try {
-          restoreFile(backupPath, originalPath);
+          // Restore from originalContent in manifest (most reliable)
+          const originalDir = path.dirname(originalPath);
+          if (!fs.existsSync(originalDir)) {
+            fs.mkdirSync(originalDir, { recursive: true });
+          }
+          fs.writeFileSync(originalPath, modified.originalContent, "utf-8");
           console.log(chalk.green(`   ✓ Restored: ${modified.path}`));
           restoredCount++;
         } catch (error) {
-          console.log(chalk.yellow(`   ⚠ Could not restore: ${modified.path}`));
-          failedRestorations.push(modified.path);
+          // Fallback to backup file if originalContent restore fails
+          const backupPath = path.join(target, ".stackpatch", "backups", modified.path.replace(/\//g, "_").replace(/\\/g, "_"));
+          if (fs.existsSync(backupPath)) {
+            try {
+              restoreFile(backupPath, originalPath);
+              console.log(chalk.green(`   ✓ Restored (from backup): ${modified.path}`));
+              restoredCount++;
+            } catch (backupError) {
+              console.log(chalk.yellow(`   ⚠ Could not restore: ${modified.path}`));
+              failedRestorations.push(modified.path);
+            }
+          } else {
+            console.log(chalk.yellow(`   ⚠ Could not restore: ${modified.path} (no backup found)`));
+            failedRestorations.push(modified.path);
+          }
         }
       } else {
-        console.log(chalk.yellow(`   ⚠ Backup not found: ${modified.path}`));
-        failedRestorations.push(modified.path);
+        // Fallback: try to restore from backup file
+        const backupPath = path.join(target, ".stackpatch", "backups", modified.path.replace(/\//g, "_").replace(/\\/g, "_"));
+        if (fs.existsSync(backupPath)) {
+          try {
+            restoreFile(backupPath, originalPath);
+            console.log(chalk.green(`   ✓ Restored (from backup): ${modified.path}`));
+            restoredCount++;
+          } catch (error) {
+            console.log(chalk.yellow(`   ⚠ Could not restore: ${modified.path}`));
+            failedRestorations.push(modified.path);
+          }
+        } else {
+          console.log(chalk.yellow(`   ⚠ Backup not found and no originalContent: ${modified.path}`));
+          failedRestorations.push(modified.path);
+        }
+      }
+
+      // Safety check: If file still contains StackPatch components after restore, manually remove them
+      if (fs.existsSync(originalPath) && modified.path.includes("layout.tsx")) {
+        try {
+          let content = fs.readFileSync(originalPath, "utf-8");
+          let needsUpdate = false;
+
+          // Remove AuthSessionProvider import
+          if (content.includes("AuthSessionProvider") && content.includes("session-provider")) {
+            content = content.replace(/import\s*{\s*AuthSessionProvider\s*}\s*from\s*["'][^"']*session-provider[^"']*["'];\s*\n?/g, "");
+            needsUpdate = true;
+          }
+
+          // Remove Toaster import
+          if (content.includes("Toaster") && content.includes("toaster")) {
+            content = content.replace(/import\s*{\s*Toaster\s*}\s*from\s*["'][^"']*toaster[^"']*["'];\s*\n?/g, "");
+            needsUpdate = true;
+          }
+
+          // Remove AuthSessionProvider wrapper
+          if (content.includes("<AuthSessionProvider>") && content.includes("</AuthSessionProvider>")) {
+            content = content.replace(/<AuthSessionProvider>\s*/g, "");
+            content = content.replace(/\s*<\/AuthSessionProvider>/g, "");
+            needsUpdate = true;
+          }
+
+          // Remove Toaster component
+          if (content.includes("<Toaster")) {
+            content = content.replace(/<Toaster\s*\/?>\s*\n?\s*/g, "");
+            needsUpdate = true;
+          }
+
+          if (needsUpdate) {
+            fs.writeFileSync(originalPath, content, "utf-8");
+            console.log(chalk.green(`   ✓ Cleaned up StackPatch components from: ${modified.path}`));
+          }
+        } catch (error) {
+          // Ignore errors in cleanup
+        }
       }
     }
 
@@ -1884,23 +2015,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.2",
   "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",