@sap-ux/fiori-migration-writer 0.0.5 → 0.0.6

package/dist/data/ui5-version.js

@@ -28,7 +28,7 @@ export async function resolveUI5VersionsForMigration(projectInfo, ui5SnapshotUrl
         onlyVersionNumbers: true,
         onlyNpmVersion: true,
         ui5SelectedVersion: ui5VersionMinForProject,
-        ...(ui5SnapshotUrl && { url: ui5SnapshotUrl })
+        ...(ui5SnapshotUrl && { snapshotVersionsHost: ui5SnapshotUrl })
     });
     return ui5Versions;
 }

package/dist/files/project-files.d.ts

@@ -7,12 +7,12 @@ import type { ImportProjectInfo, Message } from '../types.js';
 /**
  * Copy adaptation (extension) project files from templates
  *
+ * @param fs - mem-fs-editor instance for file operations
  * @param projectInfo - Project import information
  * @param snapshotUrl - URL for UI5 snapshot version
- * @param fs - mem-fs-editor instance for file operations
  * @returns Result object with fs editor, success status and messages
  */
-export declare function copyAdaptationFiles(projectInfo: ImportProjectInfo, snapshotUrl: string, fs: Editor | undefined): Promise<{
+export declare function copyAdaptationFiles(fs: Editor, projectInfo: ImportProjectInfo, snapshotUrl: string): Promise<{
     fs: Editor;
     result: boolean;
     messages: Message[];
@@ -20,10 +20,11 @@ export declare function copyAdaptationFiles(projectInfo: ImportProjectInfo, snap
 /**
  * Copy library project files from templates
  *
+ * @param fs - mem-fs editor
  * @param projectInfo - Project import information
  * @returns Result object with fs editor, success status and messages
  */
-export declare function copyLibraryFiles(projectInfo: ImportProjectInfo): Promise<{
+export declare function copyLibraryFiles(fs: Editor, projectInfo: ImportProjectInfo): Promise<{
     fs: Editor;
     result: boolean;
     messages: Message[];

package/dist/files/project-files.js

@@ -11,20 +11,18 @@ import { TemplateFileName, templatesDirPath } from '../index.js';
 import { devDependencies, ui5Dependencies, getUI5Version, determineMessage, generateToolsId, getLibraryTemplatesMap } from '../utils/common.js';
 import { ui5VersionRequestInfo } from '@sap-ux/ui5-info';
 import { applyTemplates } from '../template/template-helpers.js';
-import { getCurrentEditor, createMemFsEditor } from '../utils/fs-adapter.js';
 /**
  * Copy adaptation (extension) project files from templates
  *
+ * @param fs - mem-fs-editor instance for file operations
  * @param projectInfo - Project import information
  * @param snapshotUrl - URL for UI5 snapshot version
- * @param fs - mem-fs-editor instance for file operations
  * @returns Result object with fs editor, success status and messages
  */
-export async function copyAdaptationFiles(projectInfo, snapshotUrl, fs) {
+export async function copyAdaptationFiles(fs, projectInfo, snapshotUrl) {
     const messages = [];
     const { moduleName, moduleDescription, ui5Version, appTitle, rootPath, destination } = projectInfo;
     let result;
-    let updatedFs;
     try {
         const projectUI5Version = getUI5Version(ui5Version || ''); // Defaults to '' if latest
         const adpConfig = {
@@ -63,8 +61,8 @@ export async function copyAdaptationFiles(projectInfo, snapshotUrl, fs) {
                 fioriTools: true
             }
         };
-        updatedFs = await migrate(rootPath, adpConfig);
-        // NOTE: Caller is responsible for committing changes
+        // Write into the shared editor; caller commits the changes.
+        await migrate(rootPath, adpConfig, fs);
         result = messages.length === 0;
     }
     catch (e) {
@@ -74,24 +72,21 @@ export async function copyAdaptationFiles(projectInfo, snapshotUrl, fs) {
             description: `Error copying adaptation files: ${determineMessage(e)}`
         });
         result = false;
-        updatedFs = fs || (await import('../utils/fs-adapter.js')).createMemFsEditor();
     }
-    return { fs: updatedFs, result, messages };
+    return { fs, result, messages };
 }
 /**
  * Copy library project files from templates
  *
+ * @param fs - mem-fs editor
  * @param projectInfo - Project import information
  * @returns Result object with fs editor, success status and messages
  */
-export async function copyLibraryFiles(projectInfo) {
+export async function copyLibraryFiles(fs, projectInfo) {
     const messages = [];
     const { moduleName, rootPath } = projectInfo;
     let result;
-    let fs;
     try {
-        // Get fs from context or create new one
-        fs = getCurrentEditor() || createMemFsEditor();
         const deps = { ...devDependencies };
         delete deps.rimraf;
         const packageJson = {
@@ -113,12 +108,12 @@ export async function copyLibraryFiles(projectInfo) {
         };
         // Perform migration for Reuse Library
         // 1. Create app settings (package.json)
-        await applyTemplates(getLibraryTemplatesMap(), templateData, rootPath, TemplateFileName.LibrarySettings);
+        await applyTemplates(fs, getLibraryTemplatesMap(), templateData, rootPath, TemplateFileName.LibrarySettings);
         //2. Create ui5.yaml
-        const ui5YamlTemplate = readFile(join(templatesDirPath, TemplateFileName.LibrarySettings, TemplateFileName.UI5Yaml));
+        const ui5YamlTemplate = readFile(fs, join(templatesDirPath, TemplateFileName.LibrarySettings, TemplateFileName.UI5Yaml));
         const ui5YamlContent = render(ui5YamlTemplate, templateData.ui5Yaml, { escape: escapeXML });
         const ui5YamlJson = parse(ui5YamlContent);
-        updateFile(join(rootPath, TemplateFileName.UI5Yaml), stringify(ui5YamlJson));
+        updateFile(fs, join(rootPath, TemplateFileName.UI5Yaml), stringify(ui5YamlJson));
         result = messages.length === 0;
     }
     catch (e) {
@@ -130,7 +125,6 @@ export async function copyLibraryFiles(projectInfo) {
             description: `Error copying library files: ${errorDetail}`
         });
         result = false;
-        fs = createMemFsEditor();
     }
     return { fs, result, messages };
 }

package/dist/files/webapp.d.ts

@@ -1,21 +1,24 @@
 /**
  * Helper functions for creating and managing webapp folder structure
  */
+import type { Editor } from 'mem-fs-editor';
 import type { ImportProjectInfo } from '../types.js';
 /**
  * Create basic extension project manifest.json
  * Creates a minimal manifest needed for extension project preview
  *
+ * @param fs
  * @param rootPath
  * @param projectInfo
  */
-export declare function createExtensionProjectManifest(rootPath: string, projectInfo: ImportProjectInfo): Promise<void>;
+export declare function createExtensionProjectManifest(fs: Editor, rootPath: string, projectInfo: ImportProjectInfo): void;
 /**
  * Create webapp folder and migrate files into it
  * For projects with manifest.json at root level, creates webapp folder and moves appropriate files
  *
+ * @param fs
  * @param rootPath
  * @param projectInfo
  */
-export declare function createWebappFolderAndMigrateFiles(rootPath: string, projectInfo: ImportProjectInfo): Promise<void>;
+export declare function createWebappFolderAndMigrateFiles(fs: Editor, rootPath: string, projectInfo: ImportProjectInfo): Promise<void>;
 //# sourceMappingURL=webapp.d.ts.map

package/dist/files/webapp.js

@@ -6,7 +6,7 @@ import { stat, readdir, access } from 'node:fs/promises';
 import { fileExists, updateJSON, readFile, writeFile, deleteFile } from '../utils/index.js';
 import { DirName, FileName } from '../project-spec-types.js';
 import { CommandRunner } from '@sap-ux/nodejs-utils';
-import { mkdir, exists, isMemFsEnabled, getCurrentEditor } from '../utils/fs-adapter.js';
+import { editorHasPath } from '../utils/fs-adapter.js';
 import { MigrationTypes } from '../utils/constants.js';
 import { validateRootDirectory, validateGitRelativePath } from '../utils/path-validation.js';
 import { hasStore } from '../types/mem-fs-types.js';
@@ -27,11 +27,12 @@ async function pathExistsOnDisk(path) {
 /**
  * Move files using git and fallback to filesystem move
  *
+ * @param fs - mem-fs editor
  * @param rootPath - Project root path
  * @param dirContent - Directory entries to process
  * @param direntToFilter - Files/directories to exclude
  */
-async function moveFilesWithGitFallback(rootPath, dirContent, direntToFilter) {
+async function moveFilesWithGitFallback(fs, rootPath, dirContent, direntToFilter) {
     const runner = new CommandRunner();
     const safeRootPath = await validateRootDirectory(rootPath);
     // Move files sequentially to avoid git/filesystem race conditions
@@ -52,7 +53,7 @@ async function moveFilesWithGitFallback(rootPath, dirContent, direntToFilter) {
                 // NOSONAR - Sequential check after git required
                 const sourcePath = join(rootPath, entry.name);
                 const destPath = join(rootPath, DirName.Webapp, entry.name);
-                await recursiveMove(sourcePath, destPath); // NOSONAR - Filesystem race prevention
+                await recursiveMove(fs, sourcePath, destPath); // NOSONAR - Filesystem race prevention
             }
         }
     }
@@ -61,12 +62,13 @@ async function moveFilesWithGitFallback(rootPath, dirContent, direntToFilter) {
  * Recursively move files and directories from source to destination
  * Handles both mem-fs and real filesystem operations
  *
+ * @param fs - mem-fs editor
  * @param sourcePath - Source path
  * @param destPath - Destination path
  */
-async function recursiveMove(sourcePath, destPath) {
-    // Check if source exists (handles both mem-fs and real fs)
-    if (!(await exists(sourcePath)) && !(await pathExistsOnDisk(sourcePath))) {
+async function recursiveMove(fs, sourcePath, destPath) {
+    // Check if source exists (staged in mem-fs or on the real filesystem)
+    if (!editorHasPath(fs, sourcePath) && !(await pathExistsOnDisk(sourcePath))) {
         return; // Nothing to move
     }
     // Check if it's a directory (real fs check - mem-fs doesn't have directories)
@@ -76,41 +78,35 @@ async function recursiveMove(sourcePath, destPath) {
         isDirectory = stats.isDirectory();
     }
     if (isDirectory) {
-        // Ensure destination directory exists
-        mkdir(destPath);
-        // Read directory contents (real fs)
+        // Read directory contents (real fs); mem-fs creates directories implicitly on write
         const entries = await readdir(sourcePath, { withFileTypes: true });
         // Recursively move each entry sequentially to maintain filesystem consistency
         for (const entry of entries) {
             const srcEntry = join(sourcePath, entry.name);
             const destEntry = join(destPath, entry.name);
-            await recursiveMove(srcEntry, destEntry); // NOSONAR: Parent-child order preservation required
-        }
-        // Delete the now-empty source directory (real fs only)
-        if (!isMemFsEnabled() && (await pathExistsOnDisk(sourcePath))) {
-            const { rm } = await import('node:fs/promises');
-            await rm(sourcePath, { recursive: true, force: true });
+            await recursiveMove(fs, srcEntry, destEntry); // NOSONAR: Parent-child order preservation required
         }
     }
     else {
         // It's a file - copy it
-        const content = readFile(sourcePath);
-        writeFile(destPath, content);
+        const content = readFile(fs, sourcePath);
+        writeFile(fs, destPath, content);
         // Delete source file after copying
-        deleteFile(sourcePath);
+        deleteFile(fs, sourcePath);
     }
 }
 /**
  * Create basic extension project manifest.json
  * Creates a minimal manifest needed for extension project preview
  *
+ * @param fs
  * @param rootPath
  * @param projectInfo
  */
-export async function createExtensionProjectManifest(rootPath, projectInfo) {
+export function createExtensionProjectManifest(fs, rootPath, projectInfo) {
     // Only create if manifest doesn't exist and it's an extension project
-    if (!(await fileExists(join(rootPath, projectInfo.webappPath, FileName.Manifest))) &&
-        !(await fileExists(join(rootPath, FileName.Manifest))) &&
+    if (!fileExists(fs, join(rootPath, projectInfo.webappPath, FileName.Manifest)) &&
+        !fileExists(fs, join(rootPath, FileName.Manifest)) &&
         projectInfo.type === MigrationTypes.projectExtension) {
         // Add a basic manifest.json (not linked in component.json) needed for preview
         const manifestJson = {
@@ -149,13 +145,13 @@ export async function createExtensionProjectManifest(rootPath, projectInfo) {
             }
         };
         // Write manifest to appropriate location
-        // Check if webapp directory exists (works for both mem-fs and real fs)
-        const shouldWriteToWebapp = projectInfo.webappPath && (await exists(join(rootPath, projectInfo.webappPath)));
+        // Check if webapp directory exists (staged in mem-fs or on disk, including an empty real dir)
+        const shouldWriteToWebapp = projectInfo.webappPath && fileExists(fs, join(rootPath, projectInfo.webappPath));
         if (shouldWriteToWebapp) {
-            updateJSON(join(rootPath, projectInfo.webappPath, FileName.Manifest), manifestJson);
+            updateJSON(fs, join(rootPath, projectInfo.webappPath, FileName.Manifest), manifestJson);
         }
         else {
-            updateJSON(join(rootPath, FileName.Manifest), manifestJson);
+            updateJSON(fs, join(rootPath, FileName.Manifest), manifestJson);
             projectInfo.webappPath = '';
         }
     }
@@ -164,18 +160,18 @@ export async function createExtensionProjectManifest(rootPath, projectInfo) {
  * Create webapp folder and migrate files into it
  * For projects with manifest.json at root level, creates webapp folder and moves appropriate files
  *
+ * @param fs
  * @param rootPath
  * @param projectInfo
  */
-export async function createWebappFolderAndMigrateFiles(rootPath, projectInfo) {
+export async function createWebappFolderAndMigrateFiles(fs, rootPath, projectInfo) {
     // Only proceed if webapp path is empty and manifest exists in root
     const manifestPath = join(rootPath, FileName.Manifest);
-    const manifestExists = await fileExists(manifestPath);
+    const manifestExists = fileExists(fs, manifestPath);
     if (projectInfo.webappPath === '' && manifestExists) {
         // manifest.json is outside of webapp folder and should not be a legacy project
         // as previous block will have updated this folder structure
         // create webapp, move files into it and update current webapp path
-        mkdir(join(rootPath, DirName.Webapp));
         // List of files/directories to exclude from migration
         const direntToFilter = [
             'neo-app.json',
@@ -194,15 +190,14 @@ export async function createWebappFolderAndMigrateFiles(rootPath, projectInfo) {
             '.eslintrc',
             '.eslintrc.ext'
         ];
-        const editor = getCurrentEditor();
-        if (editor && hasStore(editor)) {
+        if (hasStore(fs)) {
             // Use mem-fs to get directory listing
             // mem-fs stores keys with forward slashes, so normalize separators for Windows compatibility
             const normalizedRoot = rootPath.replaceAll('\\', '/');
             const rootPathWithSep = normalizedRoot.endsWith('/') ? normalizedRoot : normalizedRoot + '/';
             const filesToMove = [];
             // Collect all files under root, excluding those whose top-level segment is filtered
-            editor.store.each((file) => {
+            fs.store.each((file) => {
                 const filePath = file.path.replaceAll('\\', '/'); // Normalize mem-fs keys
                 if (filePath.startsWith(rootPathWithSep)) {
                     const relativePath = filePath.substring(rootPathWithSep.length);
@@ -219,15 +214,15 @@ export async function createWebappFolderAndMigrateFiles(rootPath, projectInfo) {
                 const normalizedPath = filePath.replaceAll('\\', '/');
                 const relativePath = normalizedPath.substring(rootPathWithSep.length);
                 const destPath = join(rootPath, DirName.Webapp, relativePath);
-                const content = readFile(filePath);
-                writeFile(destPath, content);
-                deleteFile(filePath);
+                const content = readFile(fs, filePath);
+                writeFile(fs, destPath, content);
+                deleteFile(fs, filePath);
             }
         }
         else {
             // Use real filesystem - extracted to helper for reduced complexity
             const dirContent = await readdir(rootPath, { withFileTypes: true });
-            await moveFilesWithGitFallback(rootPath, dirContent, direntToFilter);
+            await moveFilesWithGitFallback(fs, rootPath, dirContent, direntToFilter);
         }
         // Update webapp path
         projectInfo.webappPath = DirName.Webapp;

package/dist/index.d.ts

@@ -45,12 +45,12 @@ export { BulkProjectMigrator } from './BulkProjectMigrator.js';
 export { createMemFsEditor } from './utils/fs-adapter.js';
 export * from './types.js';
 export * from './i18n.js';
-export { findProjectRoot, getProjectType, getMainService, hasDependency, getMinUI5VersionAsArray, type CdsUi5PluginInfo, readFile, readJSON, fileExists, writeFile, updateFile, updateJSON, deleteFile, findAllManifest, isFioriToolsProject, determineMessage } from './utils/index.js';
+export { readFile, findProjectRoot, getProjectType, getMainService, hasDependency, getMinUI5VersionAsArray, type CdsUi5PluginInfo, readJSON, fileExists, writeFile, updateFile, updateJSON, deleteFile, findAllManifest, isFioriToolsProject, determineMessage } from './utils/index.js';
 export { buildMainBackend, buildProxyConfig, buildPreviewMiddleware } from './adapters/ui5-config-helpers.js';
 export { generateUI5YamlContent, generateUI5LocalYamlContent, generateUI5MockYamlContent } from './adapters/ui5-config-adapter.js';
 export type { UI5YamlOptions } from './adapters/ui5-config-adapter.js';
 export { readManifest, getUI5Version } from './utils/manifest-and-version-utils.js';
-export { stripSpaces, escapeSingleQuotes, escapeDoubleQuotes, doesDirectoryExists } from './utils/file-system-utils.js';
+export { stripSpaces, escapeSingleQuotes, escapeDoubleQuotes, doesDirectoryExists, createDirectory, doesPropertyExist } from './utils/file-system-utils.js';
 export { generateSapLibsStr, getSourceTemplate } from './utils/migration-utils.js';
 export { getWebIDEProjectPathsAsLabels } from './utils/project-discovery.js';
 export { handleGitIgnoreFile, handlePackageJsonFile, handleLocateReuseLibsFile } from './utils/template-generators/index.js';

package/dist/index.js

@@ -54,7 +54,7 @@ export * from './types.js';
 // Public API - i18n
 export * from './i18n.js';
 // Public API - Utilities (re-export selective functions for backward compatibility)
-export { findProjectRoot, getProjectType, getMainService, hasDependency, getMinUI5VersionAsArray, readFile, readJSON, fileExists, writeFile, updateFile, updateJSON, deleteFile, findAllManifest, isFioriToolsProject, 
+export { readFile, findProjectRoot, getProjectType, getMainService, hasDependency, getMinUI5VersionAsArray, readJSON, fileExists, writeFile, updateFile, updateJSON, deleteFile, findAllManifest, isFioriToolsProject, 
 // Additional exports for test compatibility
 determineMessage } from './utils/index.js';
 // Additional exports from adapters for test compatibility
@@ -62,7 +62,7 @@ export { buildMainBackend, buildProxyConfig, buildPreviewMiddleware } from './ad
 export { generateUI5YamlContent, generateUI5LocalYamlContent, generateUI5MockYamlContent } from './adapters/ui5-config-adapter.js';
 // Additional exports from utils for test compatibility
 export { readManifest, getUI5Version } from './utils/manifest-and-version-utils.js';
-export { stripSpaces, escapeSingleQuotes, escapeDoubleQuotes, doesDirectoryExists } from './utils/file-system-utils.js';
+export { stripSpaces, escapeSingleQuotes, escapeDoubleQuotes, doesDirectoryExists, createDirectory, doesPropertyExist } from './utils/file-system-utils.js';
 export { generateSapLibsStr, getSourceTemplate } from './utils/migration-utils.js';
 export { getWebIDEProjectPathsAsLabels } from './utils/project-discovery.js';
 export { handleGitIgnoreFile, handlePackageJsonFile, handleLocateReuseLibsFile } from './utils/template-generators/index.js';

package/dist/migration-process/configuration.d.ts

@@ -2,6 +2,7 @@
  * Helper functions for preparing configuration data during migration
  */
 import type { ImportProjectInfo } from '../types.js';
+import type { Editor } from 'mem-fs-editor';
 /**
  * Configuration data prepared for migration
  */
@@ -22,10 +23,11 @@ export interface PreparedConfigurationData {
  * Prepare all configuration data needed for migration
  * Consolidates theme resolution, component mapping, and project/service data preparation
  *
+ * @param fs - mem-fs editor
  * @param projectInfo - Project information
  * @param ui5Version - UI5 version (can be undefined)
  * @param enableTypeScript - Whether TypeScript support should be enabled
  * @returns Prepared configuration data
  */
-export declare function prepareConfigurationData(projectInfo: ImportProjectInfo, ui5Version: string | undefined, enableTypeScript?: boolean): Promise<PreparedConfigurationData>;
+export declare function prepareConfigurationData(fs: Editor, projectInfo: ImportProjectInfo, ui5Version: string | undefined, enableTypeScript?: boolean): Promise<PreparedConfigurationData>;
 //# sourceMappingURL=configuration.d.ts.map

package/dist/migration-process/configuration.js

@@ -6,14 +6,15 @@ import { prepareProjectAndServiceData } from '../project/project-data.js';
  * Prepare all configuration data needed for migration
  * Consolidates theme resolution, component mapping, and project/service data preparation
  *
+ * @param fs - mem-fs editor
  * @param projectInfo - Project information
  * @param ui5Version - UI5 version (can be undefined)
  * @param enableTypeScript - Whether TypeScript support should be enabled
  * @returns Prepared configuration data
  */
-export async function prepareConfigurationData(projectInfo, ui5Version, enableTypeScript = false) {
+export async function prepareConfigurationData(fs, projectInfo, ui5Version, enableTypeScript = false) {
     // Get supported themes for the project
-    const supportedThemes = await getSupportedThemes(projectInfo, ui5Version || '');
+    const supportedThemes = await getSupportedThemes(fs, projectInfo, ui5Version || '');
     const ui5Theme = getUi5ThemeBasedOnUi5Version(ui5Version ?? '', projectInfo.ui5Theme);
     // Get component mapping based on floor plan
     const { appMigratorSrcComponentToReplace, semanticObject } = getComponentMapping(projectInfo);

package/dist/migration-process/legacy-helpers.d.ts

@@ -1,3 +1,4 @@
+import type { Editor } from 'mem-fs-editor';
 export { validateRootDirectory } from '../utils/path-validation.js';
 /**
  * Build legacy folder paths for migration
@@ -21,10 +22,11 @@ export declare function buildLegacyPaths(rootPath: string, legacyPath: string):
  * Try to move folders using git to preserve history
  * Uses relative paths from validated root directory to prevent command injection
  *
+ * @param fs - mem-fs editor
  * @param rootPath - Project root path
  * @param _paths - Legacy paths object (unused, paths rebuilt internally for security)
  */
-export declare function tryGitMove(rootPath: string, _paths: LegacyPaths): Promise<void>;
+export declare function tryGitMove(fs: Editor, rootPath: string, _paths: LegacyPaths): Promise<void>;
 /**
  * Fallback folder move using node fs
  *

package/dist/migration-process/legacy-helpers.js

@@ -3,9 +3,9 @@ import { access, readdir } from 'node:fs/promises';
 import { CommandRunner } from '@sap-ux/nodejs-utils';
 import { DirName } from '../project-spec-types.js';
 import { TemplateFileName } from '../index.js';
-import { isMemFsEnabled, getCurrentEditor, exists } from '../utils/fs-adapter.js';
 import { validateRootDirectory, validateGitRelativePath } from '../utils/path-validation.js';
 import { hasStore } from '../types/mem-fs-types.js';
+import { editorHasPath } from '../utils/fs-adapter.js';
 // Re-export for backward compatibility with tests
 export { validateRootDirectory } from '../utils/path-validation.js';
 /**
@@ -57,21 +57,21 @@ function moveMemFsDirectory(fs, fromPath, toPath) {
         fs.delete(oldPath);
     }
 }
-async function memFsMove(rootPath, paths) {
-    const editor = getCurrentEditor();
-    if (!editor || !hasStore(editor)) {
+function memFsMove(fs, rootPath, paths) {
+    if (!hasStore(fs)) {
         return;
     }
+    const editor = fs;
     // Move webapp files from src/main/webapp to webapp
-    if (await exists(paths.ffLegacyWebappPath)) {
+    if (editorHasPath(fs, paths.ffLegacyWebappPath)) {
         moveMemFsDirectory(editor, paths.ffLegacyWebappPath, join(rootPath, DirName.Webapp));
     }
-    // Move test/qunit to webapp/test/qunit
-    if (await exists(paths.ffLegacyTestQunitPath)) {
-        moveMemFsDirectory(editor, paths.ffLegacyTestQunitPath, join(paths.ffNewTestPath, 'qunit'));
+    // Move test/qunit to webapp/test (replacing the test path, not nesting under qunit)
+    if (editorHasPath(fs, paths.ffLegacyTestQunitPath)) {
+        moveMemFsDirectory(editor, paths.ffLegacyTestQunitPath, paths.ffNewTestPath);
     }
     // Move test/uiveri5 to webapp/test/uiveri5
-    if (await exists(paths.ffLegacyTestuiveri5Path)) {
+    if (editorHasPath(fs, paths.ffLegacyTestuiveri5Path)) {
         moveMemFsDirectory(editor, paths.ffLegacyTestuiveri5Path, join(paths.ffNewTestPath, 'uiveri5'));
     }
 }
@@ -93,15 +93,13 @@ async function pathExistsOnDisk(path) {
  * Try to move folders using git to preserve history
  * Uses relative paths from validated root directory to prevent command injection
  *
+ * @param fs - mem-fs editor
  * @param rootPath - Project root path
  * @param _paths - Legacy paths object (unused, paths rebuilt internally for security)
  */
-export async function tryGitMove(rootPath, _paths) {
-    // In mem-fs mode, use mem-fs operations instead of git
-    if (isMemFsEnabled()) {
-        await memFsMove(rootPath, _paths);
-        return;
-    }
+export async function tryGitMove(fs, rootPath, _paths) {
+    // Keep the in-memory store consistent by moving the staged files first.
+    memFsMove(fs, rootPath, _paths);
     const runner = new CommandRunner();
     try {
         // Validate root directory - this is the only absolute path passed to git (-C option)
@@ -144,24 +142,18 @@ export async function tryGitMove(rootPath, _paths) {
  * @param paths - Legacy paths object
  */
 export async function fallbackFsMove(rootPath, paths) {
-    // Note: In mem-fs mode, file moves are handled by git (preferred path)
-    // This fallback only works for real file system operations
-    // Mem-fs doesn't support atomic moves, so this is intentionally a no-op in mem-fs mode
-    if (isMemFsEnabled()) {
-        // Skip fallback in mem-fs mode - files should have been moved by git
-        return;
-    }
-    // Real file system fallback
-    // Use filesystem operations for cleanup
+    // Real file system fallback - always runs to clean up legacy structure from disk.
+    // In mem-fs mode the new files are already staged in the editor; the real moves here
+    // delete the old source directories so they are absent after editor.commit().
     const { default: fse } = await import('fs-extra');
     if (await pathExistsOnDisk(paths.ffLegacyWebappPath)) {
-        fse.moveSync(paths.ffLegacyWebappPath, join(rootPath, DirName.Webapp));
+        fse.moveSync(paths.ffLegacyWebappPath, join(rootPath, DirName.Webapp), { overwrite: true });
     }
     if (await pathExistsOnDisk(paths.ffLegacyTestQunitPath)) {
-        fse.moveSync(paths.ffLegacyTestQunitPath, paths.ffNewTestPath);
+        fse.moveSync(paths.ffLegacyTestQunitPath, paths.ffNewTestPath, { overwrite: true });
     }
     if (await pathExistsOnDisk(paths.ffLegacyTestuiveri5Path)) {
-        fse.moveSync(paths.ffLegacyTestuiveri5Path, paths.ffNewTestPath);
+        fse.moveSync(paths.ffLegacyTestuiveri5Path, join(paths.ffNewTestPath, 'uiveri5'), { overwrite: true });
     }
 }
 /**
@@ -172,11 +164,6 @@ export async function fallbackFsMove(rootPath, paths) {
  * @param paths - Legacy paths object
  */
 export async function cleanupEmptyDirs(rootPath, legacyPath, paths) {
-    // Note: In mem-fs mode, directory removal isn't needed
-    // Mem-fs only tracks files, not empty directories
-    if (isMemFsEnabled()) {
-        return;
-    }
     const fsextra = await import('fs-extra');
     const dirsToRemove = [join(rootPath, legacyPath), paths.ffLegacyTestPath, join(rootPath, 'src')];
     // Check and remove directories sequentially to avoid filesystem race conditions

package/dist/migration-process/legacy.d.ts

@@ -2,15 +2,17 @@
  * Helper functions for migrating legacy Fiori Elements folder structures
  * Handles migration from /src/main/webapp to /webapp structure
  */
+import type { Editor } from 'mem-fs-editor';
 import type { ImportProjectInfo } from '../types.js';
 /**
  * Migrate project from legacy Fiori Elements folder structure (/src/main/webapp) to new structure (/webapp)
  *
+ * @param fs - mem-fs editor
  * @param projectInfo - Project information including current webapp path
  * @param rootPath - Root path of the project
  * @returns Object containing updated keepIndex flag and updated webapp path
  */
-export declare function migrateLegacyFolderStructure(projectInfo: ImportProjectInfo, rootPath: string): Promise<{
+export declare function migrateLegacyFolderStructure(fs: Editor, projectInfo: ImportProjectInfo, rootPath: string): Promise<{
     keepIndex: boolean;
     webappPath: string;
 }>;