@sfdc-webapps/cli 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sfdc-webapps/cli",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "CLI tool for applying feature patches to base apps",
   "type": "module",
   "publishConfig": {
@@ -11,6 +11,7 @@
   },
   "scripts": {
     "build": "tsc",
+    "clean": "rm -rf dist",
     "dev": "tsx src/index.ts",
     "test": "vitest run",
     "test:ui": "vitest run --ui",
@@ -29,11 +30,11 @@
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^24.10.1",
     "@types/react-dom": "^19.2.3",
-    "@vitest/coverage-v8": "2.1.9",
-    "@vitest/ui": "^2.1.8",
+    "@vitest/coverage-v8": "4.0.17",
+    "@vitest/ui": "^4.0.17",
     "react-dom": "^19.2.1",
     "tsx": "^4.19.2",
     "typescript": "~5.9.3",
-    "vitest": "^2.1.8"
+    "vitest": "^4.0.17"
   }
 }

package/src/commands/apply-patches.ts

@@ -1,4 +1,4 @@
-import { cpSync, existsSync, rmSync, readdirSync, statSync, mkdirSync, unlinkSync } from 'fs';
+import { cpSync, existsSync, rmSync, readdirSync, statSync, mkdirSync, readFileSync } from 'fs';
 import { join, relative, basename, dirname, isAbsolute } from 'path';
 import { tmpdir } from 'os';
 import { randomBytes } from 'crypto';
@@ -15,15 +15,14 @@ import * as logger from '../utils/logger.js';
  */
 function discoverFiles(dir: string, baseDir: string = dir): string[] {
   const files: string[] = [];
-  const entries = readdirSync(dir);
+  const entries = readdirSync(dir, { withFileTypes: true });
 
   for (const entry of entries) {
-    const fullPath = join(dir, entry);
-    const stat = statSync(fullPath);
+    const fullPath = join(dir, entry.name);
 
-    if (stat.isDirectory()) {
+    if (entry.isDirectory()) {
       files.push(...discoverFiles(fullPath, baseDir));
-    } else if (stat.isFile()) {
+    } else if (entry.isFile()) {
       // Get relative path from baseDir
       files.push(relative(baseDir, fullPath));
     }
@@ -32,6 +31,94 @@ function discoverFiles(dir: string, baseDir: string = dir): string[] {
   return files;
 }
 
+/**
+ * Reset target directory to match base app state (excluding node_modules).
+ * This syncs the target directory with the base app before applying features.
+ */
+function resetTargetToBaseApp(targetDir: string, baseAppPath: string, targetAppName: string): void {
+  const targetAppDir = join(targetDir, 'digitalExperiences/webApplications', targetAppName);
+  const sourceWebAppPath = getWebApplicationPath(baseAppPath);
+
+  // Helper to check if path contains node_modules
+  const isNodeModulesPath = (path: string): boolean => {
+    return path.split('/').includes('node_modules');
+  };
+
+  // Step 1: Remove files/directories from target that don't exist in base app
+  const removeExtraFiles = (targetPath: string, sourcePath: string) => {
+    if (!existsSync(targetPath)) return;
+
+    const entries = readdirSync(targetPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const targetEntryPath = join(targetPath, entry.name);
+      const sourceEntryPath = join(sourcePath, entry.name);
+      const relativeFromTarget = relative(targetAppDir, targetEntryPath);
+
+      // Skip node_modules
+      if (isNodeModulesPath(relativeFromTarget)) {
+        continue;
+      }
+
+      if (!existsSync(sourceEntryPath)) {
+        // Doesn't exist in base app, remove it
+        rmSync(targetEntryPath, { recursive: true, force: true });
+        const suffix = entry.isDirectory() ? '/' : '';
+        logger.info(`Removed: ${relativeFromTarget}${suffix}`);
+      } else if (entry.isDirectory()) {
+        // Recurse into directory
+        removeExtraFiles(targetEntryPath, sourceEntryPath);
+      }
+    }
+  };
+
+  // Step 2: Copy/update files from base app to target
+  const syncFiles = (sourcePath: string, targetPath: string) => {
+    if (!existsSync(sourcePath)) return;
+
+    const entries = readdirSync(sourcePath, { withFileTypes: true });
+    for (const entry of entries) {
+      const sourceEntryPath = join(sourcePath, entry.name);
+      const targetEntryPath = join(targetPath, entry.name);
+      const relativeFromTarget = relative(targetAppDir, targetEntryPath);
+
+      // Skip node_modules
+      if (isNodeModulesPath(relativeFromTarget)) {
+        continue;
+      }
+
+      if (entry.isDirectory()) {
+        // Ensure directory exists in target
+        if (!existsSync(targetEntryPath)) {
+          mkdirSync(targetEntryPath, { recursive: true });
+        }
+        // Recurse into directory
+        syncFiles(sourceEntryPath, targetEntryPath);
+      } else if (entry.isFile()) {
+        // Copy file if it doesn't exist or is different
+        let shouldCopy = false;
+        if (!existsSync(targetEntryPath)) {
+          shouldCopy = true;
+        } else {
+          // Compare file contents
+          const sourceContent = readFileSync(sourceEntryPath);
+          const targetContent = readFileSync(targetEntryPath);
+          shouldCopy = !sourceContent.equals(targetContent);
+        }
+
+        if (shouldCopy) {
+          cpSync(sourceEntryPath, targetEntryPath);
+          logger.info(`Synced: ${relativeFromTarget}`);
+        }
+      }
+    }
+  };
+
+  logger.info('Resetting target directory to base app state...');
+  removeExtraFiles(targetAppDir, sourceWebAppPath);
+  syncFiles(sourceWebAppPath, targetAppDir);
+  logger.success('Target directory reset complete');
+}
+
 const DELETE_PREFIX = '__delete__';
 const INHERIT_PREFIX = '__inherit__';
 const PREPEND_PREFIX = '__prepend__';
@@ -418,7 +505,7 @@ async function applySingleFeature(
       } finally {
         // Clean up temp file
         if (tempFilePath && existsSync(tempFilePath)) {
-          unlinkSync(tempFilePath);
+          rmSync(tempFilePath, { force: true });
         }
       }
     }
@@ -433,7 +520,7 @@ async function applySingleFeature(
  * @param options - Configuration options
  * @param options.targetDirName - Required. Target directory where feature will be applied
  * @param options.skipDependencyChanges - Optional. Skip npm dependency installation
- * @param options.clean - Optional. Clean target directory before applying
+ * @param options.reset - Optional. Reset target directory to base app state before applying (preserves node_modules)
  *
  * @example
  * await applyPatchesCommand(
@@ -445,7 +532,7 @@ async function applySingleFeature(
 export async function applyPatchesCommand(
   featurePath: string,
   appPath: string,
-  options: { targetDirName: string; skipDependencyChanges?: boolean; clean?: boolean; }
+  options: { targetDirName: string; skipDependencyChanges?: boolean; reset?: boolean; }
 ): Promise<void> {
   try {
     logger.heading(`Applying patches: ${featurePath} → ${options.targetDirName}`);
@@ -466,25 +553,26 @@ export async function applyPatchesCommand(
       ? options.targetDirName
       : join(getMonorepoRoot(), options.targetDirName);
 
+    // Calculate target app directory path
+    const targetAppDir = join(resolvedTargetDir, 'digitalExperiences/webApplications', targetAppName);
+
     if (existsSync(resolvedTargetDir)) {
-      if (options.clean) {
-        logger.info(`Cleaning existing directory ${options.targetDirName}...`);
-        rmSync(resolvedTargetDir, { recursive: true, force: true });
-        logger.success('Directory cleaned');
+      if (options.reset) {
+        // Reset target to base app state (preserving node_modules)
+        resetTargetToBaseApp(resolvedTargetDir, baseAppPath, targetAppName);
       }
     } else {
       logger.info(`Creating target directory ${options.targetDirName}...`);
       mkdirSync(resolvedTargetDir, { recursive: true });
       logger.success('Target directory created');
-    }
 
-    // Copy base app to target directory with nested structure
-    logger.info(`Copying base app to ${options.targetDirName}...`);
-    const targetAppDir = join(resolvedTargetDir, 'digitalExperiences/webApplications', targetAppName);
-    const sourceWebAppPath = getWebApplicationPath(baseAppPath);
-    mkdirSync(dirname(targetAppDir), { recursive: true });
-    cpSync(sourceWebAppPath, targetAppDir, { recursive: true });
-    logger.success('Base app copied');
+      // Copy base app to target directory with nested structure
+      logger.info(`Copying base app to ${options.targetDirName}...`);
+      const sourceWebAppPath = getWebApplicationPath(baseAppPath);
+      mkdirSync(dirname(targetAppDir), { recursive: true });
+      cpSync(sourceWebAppPath, targetAppDir, { recursive: true });
+      logger.success('Base app copied');
+    }
 
     const targetDir = resolvedTargetDir;
 

package/src/commands/new-app-feature.ts

@@ -70,20 +70,13 @@ export async function newAppOrFeatureCommand(appOrFeatureName: string, appOrFeat
         // Update scripts to reference new feature name
         // Replace both "base-feature" and any existing "feature-*" patterns
         const regexPattern = new RegExp(`base-${templateName}`, 'g');
-        if (packageJson.scripts) {
-            if (packageJson.scripts.dev) {
-                packageJson.scripts.dev = packageJson.scripts.dev
+        const commandsToUpdate = ['dev', 'build', 'watch'];
+        commandsToUpdate.forEach(command => {
+            if (packageJson.scripts[command]) {
+                packageJson.scripts[command] = packageJson.scripts[command]
                     .replace(regexPattern, fullFeatureName);
             }
-            if (packageJson.scripts['test-patch']) {
-                packageJson.scripts['test-patch'] = packageJson.scripts['test-patch']
-                    .replace(regexPattern, fullFeatureName);
-            }
-            if (packageJson.scripts.watch) {
-                packageJson.scripts.watch = packageJson.scripts.watch
-                    .replace(regexPattern, fullFeatureName);
-            }
-        }
+        });
 
         writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
         logger.success('package.json updated');

package/src/commands/watch-patches.ts

@@ -1,17 +1,14 @@
 import { watch, type ChangeEvent } from 'turbowatch';
-import { join, relative, basename } from 'path';
-import { existsSync, cpSync, rmSync } from 'fs';
+import { join } from 'path';
 import { applyPatchesCommand } from './apply-patches.js';
 import { validateAndResolveFeaturePath, validateAndResolveAppPath } from '../utils/validation.js';
-import { getMonorepoRoot, translatePathToBaseApp } from '../utils/paths.js';
 import { loadFeature } from '../core/patch-loader.js';
 import * as logger from '../utils/logger.js';
 
 export async function watchPatchesCommand(
   featurePath: string,
   appPath: string,
-  targetDirName: string,
-  options: { clean?: boolean } = {}
+  targetDirName: string
 ): Promise<{ shutdown: () => Promise<void> }> {
   try {
     logger.heading(`Starting watch mode for ${featurePath}...`);
@@ -23,11 +20,12 @@ export async function watchPatchesCommand(
     logger.success('Validation passed');
 
     // Step 2: Apply feature initially (with dependencies)
+    // Always reset to ensure clean state (preserves node_modules)
     logger.info('Applying feature initially...');
     await applyPatchesCommand(featurePath, appPath, {
       targetDirName: targetDirName,
       skipDependencyChanges: false,
-      clean: options.clean
+      reset: true
     });
     logger.success('Initial feature applied successfully\n');
 
@@ -35,11 +33,6 @@ export async function watchPatchesCommand(
     const { templateDir } = await loadFeature(featureDir);
     const watchPath = join(featureDir, templateDir);
 
-    // Resolve base app and target directory paths
-    const baseAppPath = validateAndResolveAppPath(appPath);
-    const monorepoRoot = getMonorepoRoot();
-    const targetDir = targetDirName ? join(monorepoRoot, targetDirName) : baseAppPath;
-
     logger.info(`👁  Watching ${watchPath} for changes...`);
     logger.info('   Press Ctrl+C to stop watching\n');
 
@@ -51,10 +44,11 @@ export async function watchPatchesCommand(
         logger.info('⟳  Re-applying feature...\n');
 
         const startTime = Date.now();
+        // Reset on file changes to remove stale files (preserves node_modules)
         await applyPatchesCommand(featurePath, appPath, {
           targetDirName: targetDirName,
           skipDependencyChanges: true,
-          clean: options.clean
+          reset: true
         });
         const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
 
@@ -80,42 +74,6 @@ export async function watchPatchesCommand(
       }
     };
 
-    // Handle file deletion - restore base app file if it exists, otherwise delete
-    const handleDeletion = async (deletedPath: string) => {
-      try {
-        const relativePath = deletedPath.replace(watchPath + '/', '');
-        logger.info(`🗑  Deletion detected in ${relativePath}`);
-
-        // Calculate paths
-        const relativeFromFeature = relative(watchPath, deletedPath);
-        const featureName = basename(featurePath);
-
-        // Translate the path to the base app structure
-        const translatedPath = translatePathToBaseApp(relativeFromFeature, featureName, baseAppPath);
-        const targetFilePath = join(targetDir, translatedPath);
-        const baseFilePath = join(baseAppPath, translatedPath);
-
-        // Check if file exists in base app
-        if (existsSync(baseFilePath)) {
-          // Restore base app version
-          cpSync(baseFilePath, targetFilePath);
-          logger.success(`✓ Restored base app version of ${translatedPath}`);
-        } else {
-          // No base version, delete from target
-          if (existsSync(targetFilePath)) {
-            rmSync(targetFilePath);
-            logger.success(`✓ Deleted ${translatedPath}`);
-          }
-        }
-
-        logger.info('👁  Watching for changes...\n');
-      } catch (err) {
-        logger.error(`\n✗ Failed to handle deletion: ${err instanceof Error ? err.message : String(err)}`);
-        logger.info('   Will retry on next file change');
-        logger.info('👁  Watching for changes...\n');
-      }
-    };
-
     // Set up turbowatch watcher
     const controller = await watch({
       project: watchPath,
@@ -127,12 +85,11 @@ export async function watchPatchesCommand(
           expression: ['anyof', ['match', '*.tsx', 'basename'], ['match', '*.ts', 'basename'], ['match', '*.css', 'basename']],
           name: 'source-files',
           onChange: async ({ files }: ChangeEvent) => {
+            //Reset will handle all changes (additions, modifications, deletions)
+            // We just need to trigger a single re-apply when any change is detected
             for (const file of files) {
-              // Check if file still exists to detect deletions
-              if (!existsSync(file.name)) {
-                await handleDeletion(file.name);
-              }
               await applyPatches(file.name);
+              break; // Only apply once per batch of changes
             }
           }
         }

package/src/index.ts

@@ -2,7 +2,6 @@
 
 import { Command } from 'commander';
 import { applyPatchesCommand } from './commands/apply-patches.js';
-import { watchPatchesCommand } from './commands/watch-patches.js';
 import { readFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
@@ -27,13 +26,13 @@ program
   .argument('<app-path>', 'Path to the app (e.g., packages/base-react-app or my-app)')
   .argument('<target-dir>', 'Target directory to copy app to before applying patches')
   .option('--skip-dependency-changes', 'Skip installing dependencies from package.json')
-  .option('--clean', 'Remove target directory if it exists before applying patches')
-  .action(async (featurePath: string, appPath: string, targetDir: string, options: { skipDependencyChanges?: boolean; clean?: boolean }) => {
+  .option('--reset', 'Reset target directory to base app state before applying patches (preserves node_modules)')
+  .action(async (featurePath: string, appPath: string, targetDir: string, options: { skipDependencyChanges?: boolean; reset?: boolean }) => {
     try {
       await applyPatchesCommand(featurePath, appPath, {
         targetDirName: targetDir,
         skipDependencyChanges: options.skipDependencyChanges,
-        clean: options.clean
+        reset: options.reset
       });
       process.exit(0);
     } catch (err) {
@@ -47,10 +46,11 @@ program
   .argument('<feature-path>', 'Path to the feature (e.g., packages/feature-navigation-menu)')
   .argument('<app-path>', 'Path to the app (e.g., packages/base-react-app or my-app)')
   .argument('<target-dir>', 'Target directory to apply patches to')
-  .option('--clean', 'Remove target directory if it exists before applying patches')
-  .action(async (featurePath: string, appPath: string, targetDir: string, options: { clean?: boolean }) => {
+  .action(async (featurePath: string, appPath: string, targetDir: string) => {
     try {
-      await watchPatchesCommand(featurePath, appPath, targetDir, options);
+      // Dynamic import to avoid loading turbowatch when not needed
+      const { watchPatchesCommand } = await import('./commands/watch-patches.js');
+      await watchPatchesCommand(featurePath, appPath, targetDir);
     } catch (err) {
       process.exit(1);
     }

package/test/e2e/watch-patches.spec.ts

@@ -40,10 +40,15 @@ describe('watch-patches E2E', () => {
       watchProcess = watcher.process;
 
       // Wait for initial application (longer timeout for spawned process)
-      await new Promise(resolve => setTimeout(resolve, 1500));
+      // Use retry loop to handle timing variations
+      const targetFile = join(targetDir, 'digitalExperiences/webApplications/watch-basic/src/placeholder.tsx');
+      let retries = 0;
+      while (!existsSync(targetFile) && retries < 20) {
+        await new Promise(resolve => setTimeout(resolve, 250));
+        retries++;
+      }
 
       // Verify initial application
-      const targetFile = join(targetDir, 'digitalExperiences/webApplications/watch-basic/src/placeholder.tsx');
       expect(existsSync(targetFile)).toBe(true);
       const initialContent = readFileSync(targetFile, 'utf-8');
 
@@ -81,12 +86,16 @@ describe('watch-patches E2E', () => {
       const watcher = spawnWatchPatches(featureDir, baseAppDir, targetDir, { clean: false });
       watchProcess = watcher.process;
 
-      // Wait for initial application (longer timeout for spawned process)
-      await new Promise(resolve => setTimeout(resolve, 1500));
-
       const featureFile = join(featureDir, 'template/digitalExperiences/webApplications/watch-debounce/src/placeholder.tsx');
       const targetFile = join(targetDir, 'digitalExperiences/webApplications/watch-debounce/src/placeholder.tsx');
 
+      // Wait for initial application with retry
+      let retries = 0;
+      while (!existsSync(targetFile) && retries < 20) {
+        await new Promise(resolve => setTimeout(resolve, 250));
+        retries++;
+      }
+
       // Track how many times the file changed
       let changeCount = 0;
       const originalContent = readFileSync(targetFile, 'utf-8');
@@ -124,12 +133,17 @@ describe('watch-patches E2E', () => {
       const featureDir = join(tempDir, 'watch-multiple-feature');
       copyFixture('watch/watch-multiple-files', featureDir);
 
-      // Start watch mode via CLI
-      const watcher = spawnWatchPatches(featureDir, baseAppDir, targetDir, { clean: false });
+      // Start watch mode via CLI (always resets to base app state, preserving node_modules)
+      const watcher = spawnWatchPatches(featureDir, baseAppDir, targetDir);
       watchProcess = watcher.process;
 
-      // Wait for initial application (longer timeout for spawned process)
-      await new Promise(resolve => setTimeout(resolve, 1500));
+      // Wait for initial application with retry - check for a known file from the fixture
+      const initialFile = join(targetDir, 'digitalExperiences/webApplications/watch-multiple-files/src/placeholder.tsx');
+      let initRetries = 0;
+      while (!existsSync(initialFile) && initRetries < 20) {
+        await new Promise(resolve => setTimeout(resolve, 250));
+        initRetries++;
+      }
 
       // Modify multiple files
       const componentsDir = join(featureDir, 'template/digitalExperiences/webApplications/watch-multiple-files/src/components');
@@ -142,12 +156,18 @@ describe('watch-patches E2E', () => {
       await new Promise(resolve => setTimeout(resolve, 100));
       writeFileSync(join(stylesDir, 'theme.css'), '/* Theme styles */');
 
-      // Wait for changes to be applied
-      await new Promise(resolve => setTimeout(resolve, 1000));
+      // Wait for changes to be applied with retry
+      const headerFile = join(targetDir, 'digitalExperiences/webApplications/watch-multiple-files/src/components/Header.tsx');
+      const themeFile = join(targetDir, 'digitalExperiences/webApplications/watch-multiple-files/src/styles/theme.css');
+      let retries = 0;
+      while ((!existsSync(headerFile) || !existsSync(themeFile)) && retries < 20) {
+        await new Promise(resolve => setTimeout(resolve, 250));
+        retries++;
+      }
 
       // Verify both files were applied
-      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/watch-multiple-files/src/components/Header.tsx'))).toBe(true);
-      expect(existsSync(join(targetDir, 'digitalExperiences/webApplications/watch-multiple-files/src/styles/theme.css'))).toBe(true);
+      expect(existsSync(headerFile)).toBe(true);
+      expect(existsSync(themeFile)).toBe(true);
 
       // Stop watch mode
       if (watchProcess) {
@@ -166,23 +186,32 @@ describe('watch-patches E2E', () => {
       const featureDir = join(tempDir, 'watch-add-delete-feature');
       copyFixture('watch/watch-add-delete-files', featureDir);
 
-      // Start watch mode via CLI
-      const watcher = spawnWatchPatches(featureDir, baseAppDir, targetDir, { clean: false });
+      // Start watch mode via CLI (always resets to base app state, preserving node_modules)
+      const watcher = spawnWatchPatches(featureDir, baseAppDir, targetDir);
       watchProcess = watcher.process;
 
-      // Wait for initial application (longer timeout for spawned process)
-      await new Promise(resolve => setTimeout(resolve, 1500));
+      // Wait for initial application with retry
+      const initialFile = join(targetDir, 'digitalExperiences/webApplications/watch-add-delete-files/src/placeholder.tsx');
+      let initRetries = 0;
+      while (!existsSync(initialFile) && initRetries < 20) {
+        await new Promise(resolve => setTimeout(resolve, 250));
+        initRetries++;
+      }
 
       // Add a new file to the feature
       const srcDir = join(featureDir, 'template/digitalExperiences/webApplications/watch-add-delete-files/src');
       const newFile = join(srcDir, 'NewComponent.tsx');
       writeFileSync(newFile, '// New component added during watch');
 
-      // Wait for detection and application
-      await new Promise(resolve => setTimeout(resolve, 1000));
+      // Wait for detection and application with retry
+      const targetNewFile = join(targetDir, 'digitalExperiences/webApplications/watch-add-delete-files/src/NewComponent.tsx');
+      let retries = 0;
+      while (!existsSync(targetNewFile) && retries < 20) {
+        await new Promise(resolve => setTimeout(resolve, 250));
+        retries++;
+      }
 
       // Verify new file was applied
-      const targetNewFile = join(targetDir, 'digitalExperiences/webApplications/watch-add-delete-files/src/NewComponent.tsx');
       expect(existsSync(targetNewFile)).toBe(true);
       expect(readFileSync(targetNewFile, 'utf-8')).toContain('New component added during watch');
 
@@ -194,44 +223,5 @@ describe('watch-patches E2E', () => {
       }
     }, 10000);
 
-    it('should handle file deletions during watch', async () => {
-      // Setup
-      const baseAppDir = copyFixture('base-app', join(tempDir, 'base-app'));
-      const targetDir = join(tempDir, 'watch-delete-target');
-      const featureDir = join(tempDir, 'watch-delete-feature');
-      copyFixture('watch/watch-add-delete-files', featureDir);
-
-      // Start watch mode with clean: true to properly handle deletions via CLI
-      const watcher = spawnWatchPatches(featureDir, baseAppDir, targetDir, { clean: true });
-      watchProcess = watcher.process;
-
-      // Wait for initial application (longer timeout for spawned process)
-      await new Promise(resolve => setTimeout(resolve, 1500));
-
-      // Verify initial file exists
-      const initialFile = join(featureDir, 'template/digitalExperiences/webApplications/watch-add-delete-files/src/initial.tsx');
-      const targetInitialFile = join(targetDir, 'digitalExperiences/webApplications/watch-add-delete-files/src/initial.tsx');
-      expect(existsSync(targetInitialFile)).toBe(true);
-
-      // Delete a file from the feature
-      if (existsSync(initialFile)) {
-        unlinkSync(initialFile);
-      }
-
-      // Wait for detection and handling
-      await new Promise(resolve => setTimeout(resolve, 1000));
-
-      // After deletion, the file should be restored from base app or removed
-      // (depending on whether it exists in base app)
-      // For this test, since it's a feature-specific file, it should be removed
-      expect(existsSync(targetInitialFile)).toBe(false);
-
-      // Stop watch mode
-      if (watchProcess) {
-        watchProcess.kill('SIGTERM');
-        await new Promise(resolve => setTimeout(resolve, 100));
-        watchProcess = null;
-      }
-    }, 10000);
   });
 });

package/test/helpers/cli-runner.ts

@@ -56,7 +56,7 @@ export async function runApplyPatches(
   featurePath: string,
   appPath: string,
   targetDir: string,
-  options: { skipDependencyChanges?: boolean; clean?: boolean } = {}
+  options: { skipDependencyChanges?: boolean; reset?: boolean } = {}
 ): Promise<CliResult> {
   const args = ['apply-patches', featurePath, appPath, targetDir];
 
@@ -64,8 +64,8 @@ export async function runApplyPatches(
     args.push('--skip-dependency-changes');
   }
 
-  if (options.clean) {
-    args.push('--clean');
+  if (options.reset) {
+    args.push('--reset');
   }
 
   return runCli(args);
@@ -74,19 +74,15 @@ export async function runApplyPatches(
 /**
  * Runs watch-patches command via CLI
  * Note: For watch mode, caller must handle terminating the process
+ * Watch mode always resets to base app state on each change (preserving node_modules)
  */
 export function spawnWatchPatches(
   featurePath: string,
   appPath: string,
-  targetDir: string,
-  options: { clean?: boolean } = {}
+  targetDir: string
 ): { process: ReturnType<typeof spawn>; kill: () => void } {
   const args = ['watch-patches', featurePath, appPath, targetDir];
 
-  if (options.clean) {
-    args.push('--clean');
-  }
-
   const child = spawn('tsx', [CLI_PATH, ...args], {
     env: { ...process.env, FORCE_COLOR: '0' }
   });