@superblocksteam/vite-plugin-file-sync 2.0.75-next.3 → 2.0.75

package/dist/file-system-manager.js

@@ -1,13 +1,15 @@
 import fs from "fs/promises";
-import nodePath from "node:path";
+import path from "node:path";
 import * as t from "@babel/types";
 import { PROCESSED_TRANSACTIONS_ATTRIBUTE, ROOT_WIDGET_ATTRIBUTE, SOURCE_ID_ATTRIBUTE, WIDGET_DISABLE_DND, } from "@superblocksteam/library-shared";
 import { addTracingToMethods, TracedEventEmitter, } from "@superblocksteam/shared";
 import { readAppApiYamlFile, writeApiFiles, } from "@superblocksteam/util";
 import { glob } from "glob";
 import { isEqual, debounce } from "lodash-es";
-import { normalizePath } from "vite";
 import yaml from "yaml";
+import { Paths } from "./ai-service/const.js";
+import { YamlToApiBuilderTransformer } from "./ai-service/transform/api-builder/to-sdk-transformer.js";
+import { applyFileTransformations, renderPath, } from "./ai-service/transform/shared.js";
 import { generateJSXAttribute } from "./codegen.js";
 import { ComponentsManager } from "./components-manager.js";
 import { addLegacyCustomComponentVariables, modifyLegacyCustomComponentElements, modifyLegacyCustomComponentImports, } from "./custom-components.js";
@@ -114,13 +116,13 @@ export class FileSystemManager extends TracedEventEmitter {
         if (!this.rootDir) {
             throw new Error("Root directory not set");
         }
-        return nodePath.join(this.rootDir, "App.tsx");
+        return path.join(this.rootDir, "App.tsx");
     }
     get rootScopeFilePath() {
         if (!this.rootDir) {
             throw new Error("Root directory not set");
         }
-        return nodePath.join(this.rootDir, SCOPE_FILE);
+        return path.join(this.rootDir, SCOPE_FILE);
     }
     // MARK: core setup/init
     async watch(watcher, rootPath) {
@@ -128,7 +130,7 @@ export class FileSystemManager extends TracedEventEmitter {
         this.rootDir = rootPath;
         this.watcher = watcher;
         // APIs and pages are in the pages subfolder
-        const fileNames = await readFiles(nodePath.join(rootPath));
+        const fileNames = await readFiles(path.join(rootPath));
         // this reads all files excluding ignore list in the root path. Should we read all files in pages and add root.tsx and App.tsx instead?
         const tsxFiles = fileNames.filter((f) => f.endsWith(".tsx") && !f.includes(`${getLegacyComponentsFolder()}/`));
         const yamlFiles = fileNames.filter((f) => f.endsWith(".yaml"));
@@ -166,7 +168,7 @@ export class FileSystemManager extends TracedEventEmitter {
             // We only want to load the typescript files here, before the source tracker is initialized
             // API setup needs to be deferred until we've parsed the scope files (which is done in the source tracker)
             if (type === "tsx" || type === "ts") {
-                this.tsFiles[normalizePath(path)] = content;
+                this.tsFiles[path] = content;
             }
         });
         try {
@@ -285,22 +287,21 @@ export class FileSystemManager extends TracedEventEmitter {
         if (!this.sourceTracker) {
             throw new Error("Source tracker not initialized");
         }
-        const normalizedPath = normalizePath(filePath);
         const files = this.sourceTracker.getCurrentFiles();
-        if (!files[normalizedPath]) {
-            throw new Error("File not found in source tracker " + normalizedPath);
+        if (!files[filePath]) {
+            throw new Error("File not found in source tracker " + filePath);
         }
-        let ast = files[normalizedPath].ast;
+        let ast = files[filePath].ast;
         if (!ast) {
-            throw new Error("No AST found for file in source tracker " + normalizedPath);
+            throw new Error("No AST found for file in source tracker " + filePath);
         }
-        if (normalizedPath in this.tsFiles &&
-            this.tsFiles[normalizedPath] &&
-            files[normalizedPath].code !== this.tsFiles[normalizedPath]) {
+        if (filePath in this.tsFiles &&
+            this.tsFiles[filePath] &&
+            files[filePath].code !== this.tsFiles[filePath]) {
             getLogger().error("File code mismatch in source tracker, this should never happen: " +
                 filePath);
-            await this.handleNonVisualChangeByDeletingIds(filePath, this.tsFiles[normalizedPath]);
-            const newAst = this.sourceTracker.getCurrentFiles()[normalizedPath]?.ast;
+            await this.handleNonVisualChangeByDeletingIds(filePath, this.tsFiles[filePath]);
+            const newAst = this.sourceTracker.getCurrentFiles()[filePath]?.ast;
             if (!newAst) {
                 throw new Error("No AST found for file in source tracker after mismatch:" + filePath);
             }
@@ -455,49 +456,46 @@ export class FileSystemManager extends TracedEventEmitter {
             return;
         }
         const fileType = SUPPORTED_FILETYPES.find((f) => filePath.endsWith(f.extension));
-        // Normalize both paths for comparison (Windows compatibility)
-        const normalizedFilePath = normalizePath(filePath);
-        const normalizedRootPath = normalizePath(rootPath);
         // Only handle files we care about and that are in our root path
-        if (!fileType || !normalizedFilePath.startsWith(normalizedRootPath)) {
+        if (!fileType || !filePath.startsWith(rootPath)) {
             return;
         }
         // Queue the operation based on the event type
         switch (event) {
             case "add": {
-                const file = await readFile(normalizedFilePath);
+                const file = await readFile(filePath);
                 if (typeof file !== "string")
                     return;
                 switch (fileType.type) {
                     case "api":
                     case "python-api-step":
                     case "js-api-step": {
-                        await this.processApiFileUpdates(normalizedFilePath, fileType);
+                        await this.processApiFileUpdates(filePath, fileType);
                         break;
                     }
                     case "ts":
                     case "tsx":
-                        if (!(normalizedFilePath in this.tsFiles)) {
-                            this.tsFiles[normalizedFilePath] = file;
-                            await this.handleNonVisualChangeByDeletingIds(normalizedFilePath, file);
-                            this.emit("fileChanged", normalizedFilePath, file, true);
+                        if (!(filePath in this.tsFiles)) {
+                            this.tsFiles[filePath] = file;
+                            await this.handleNonVisualChangeByDeletingIds(filePath, file);
+                            this.emit("fileChanged", filePath, file, true);
                             return;
                         }
                 }
                 break;
             }
             case "change": {
-                const fileType = SUPPORTED_FILETYPES.find((f) => normalizedFilePath.endsWith(f.extension));
-                if (!fileType || !normalizedFilePath.startsWith(rootPath)) {
+                const fileType = SUPPORTED_FILETYPES.find((f) => filePath.endsWith(f.extension));
+                if (!fileType || !filePath.startsWith(rootPath)) {
                     return;
                 }
-                const data = await readFile(normalizedFilePath);
+                const data = await readFile(filePath);
                 if (typeof data !== "string")
                     return;
                 // Handle router file changes
-                if (this.routerFilePath && normalizedFilePath === this.routerFilePath) {
+                if (this.routerFilePath && filePath === this.routerFilePath) {
                     logger.info("Router file changed, emitting routerChange event");
-                    this.emit("routerChange", normalizedFilePath);
+                    this.emit("routerChange", filePath);
                     return;
                 }
                 switch (fileType.type) {
@@ -505,18 +503,17 @@ export class FileSystemManager extends TracedEventEmitter {
                     case "tsx":
                     case "scope":
                         {
-                            if (!(normalizedFilePath in this.tsFiles &&
-                                this.tsFiles[normalizedFilePath] === data)) {
-                                logger.info(`File changed: ${normalizedFilePath} updating AST tracker`);
-                                this.tsFiles[normalizedFilePath] = data;
+                            if (!(filePath in this.tsFiles && this.tsFiles[filePath] === data)) {
+                                logger.info(`File changed: ${filePath} updating AST tracker`);
+                                this.tsFiles[filePath] = data;
                                 // only update the source tracker if the file is different
-                                await this.handleNonVisualChangeByDeletingIds(normalizedFilePath, data);
-                                this.emit("fileChanged", normalizedFilePath, data, true);
+                                await this.handleNonVisualChangeByDeletingIds(filePath, data);
+                                this.emit("fileChanged", filePath, data, true);
                             }
                             else {
-                                logger.info(`File unchanged from last tracked state: ${normalizedFilePath}`);
-                                this.emit("fileChanged", normalizedFilePath, data, false);
-                                this.sourceTracker?.updateFileContents(normalizedFilePath, data);
+                                logger.info(`File unchanged from last tracked state: ${filePath}`);
+                                this.emit("fileChanged", filePath, data, false);
+                                this.sourceTracker?.updateFileContents(filePath, data);
                             }
                         }
                         break;
@@ -524,17 +521,16 @@ export class FileSystemManager extends TracedEventEmitter {
                     case "python-api-step":
                     case "js-api-step":
                         {
-                            await this.processApiFileUpdates(normalizedFilePath, fileType);
+                            await this.processApiFileUpdates(filePath, fileType);
                         }
                         break;
                 }
                 break;
             }
             case "unlink": {
-                if (normalizedFilePath in this.tsFiles) {
-                    await this.deleteTsFile(normalizedFilePath);
-                    if (this.routerFilePath &&
-                        normalizedFilePath === this.routerFilePath) {
+                if (filePath in this.tsFiles) {
+                    await this.deleteTsFile(filePath);
+                    if (this.routerFilePath && filePath === this.routerFilePath) {
                         logger.warn("Router file was deleted, attempting to find new router file");
                         try {
                             this.routerFilePath = await findRouterFile(rootPath);
@@ -548,19 +544,18 @@ export class FileSystemManager extends TracedEventEmitter {
                         }
                     }
                 }
-                else if (normalizedFilePath in this.apiFiles) {
-                    await this.removeApiData(normalizedFilePath);
+                else if (filePath in this.apiFiles) {
+                    await this.removeApiData(filePath);
                 }
                 break;
             }
         }
     };
     async deleteTsFile(filePath) {
-        const normalizedPath = normalizePath(filePath);
-        delete this.tsFiles[normalizedPath];
-        this.sourceTracker?.removeFile(normalizedPath);
-        if (isPageFilePath(normalizedPath)) {
-            this.emit("deletePage", normalizedPath);
+        delete this.tsFiles[filePath];
+        this.sourceTracker?.removeFile(filePath);
+        if (isPageFilePath(filePath)) {
+            this.emit("deletePage", filePath);
         }
     }
     getTsFilePaths() {
@@ -576,14 +571,65 @@ export class FileSystemManager extends TracedEventEmitter {
     setTemplateRenderer(templateRenderer) {
         this.templateRenderer = templateRenderer;
     }
+    /**
+     * Generate TypeScript source from YAML and write to scratch directory
+     * This is called when YAML changes (e.g., UI edits) to keep TS in sync.
+     */
+    syncTsFromYaml = debounce((apiName) => {
+        return this.fsOperationQueue.enqueue(() => this._syncTsFromYaml(apiName));
+    }, 250, { leading: true, trailing: true, maxWait: 500 });
+    async _syncTsFromYaml(apiName) {
+        const logger = getLogger();
+        // Skip if we don't have templateRenderer
+        if (!this.templateRenderer || !this.rootDir) {
+            logger.warn(`Skipping YAML→TS sync for ${apiName}: templateRenderer or rootDir not available`);
+            return;
+        }
+        logger.info(`Starting YAML→TS sync for: ${apiName}`);
+        try {
+            const yamlPath = renderPath(Paths.ApiYamls, { apiName });
+            logger.debug(`Syncing TS source from YAML for API: ${apiName}`);
+            // Create file artifact for transformation
+            const yamlArtifact = {
+                type: "file",
+                filePath: yamlPath,
+                content: "", // Transformer just needs the path
+            };
+            // Transform YAML to TS
+            const outputs = await applyFileTransformations([yamlArtifact], [
+                new YamlToApiBuilderTransformer({
+                    appRootDirPath: this.rootDir,
+                    entityNames: [], // Empty for now, could be enhanced later
+                    skipCleanup: true,
+                    templateRenderer: this.templateRenderer,
+                }),
+            ]);
+            const tsArtifact = outputs[0];
+            if (!tsArtifact) {
+                logger.warn(`No TS artifact generated for ${apiName}`);
+                return;
+            }
+            logger.debug(`Generated TS source for ${apiName}, writing to scratch`, tsArtifact.content);
+            // Write to scratch directory
+            const apiTsFilePath = `${renderPath(Paths.GeneratedApis, { apiName })}.ts`;
+            const scratchPath = renderPath(Paths.Scratch, { path: apiTsFilePath });
+            const fullPath = path.join(this.rootDir, scratchPath);
+            await fs.mkdir(path.dirname(fullPath), { recursive: true });
+            await fs.writeFile(fullPath, tsArtifact.content, { encoding: "utf-8" });
+            logger.info(`✓ Synced TS source to scratch for ${apiName}`);
+        }
+        catch (error) {
+            logger.error(`Failed to sync TS from YAML for ${apiName}`, getErrorMeta(error));
+            // Don't throw - sync failure shouldn't break the API update
+        }
+    }
     // MARK: fs read/write
     async writeFile(path, content, kind) {
         getLogger().info(`Writing file: ${path}, kind: ${kind ?? "other"}`);
         switch (kind) {
             case "ts": {
                 // happens eagerly regardless of error - possible desync
-                const normalizedPath = normalizePath(path);
-                this.tsFiles[normalizedPath] = content;
+                this.tsFiles[path] = content;
                 // TODO(george): as an optimization, we could update the memory snapshot of the file that SyncService is holding
                 await this.fsOperationQueue.enqueue(async () => {
                     const dir = path.substring(0, path.lastIndexOf("/"));
@@ -595,8 +641,7 @@ export class FileSystemManager extends TracedEventEmitter {
                 break;
             }
             case "api": {
-                const normalizedPath = normalizePath(path);
-                const currentApiFile = this.apiFiles[normalizedPath];
+                const currentApiFile = this.apiFiles[path];
                 const apiPb = yaml.parse(content);
                 // We don't need ID, organization, or trigger data in code-mode APIs
                 if (apiPb.metadata) {
@@ -610,15 +655,14 @@ export class FileSystemManager extends TracedEventEmitter {
                 const scopeId = getScopeIdFromName("App");
                 // Update in-memory state before writing to disk (similar to TS files)
                 // This allows the file watcher to detect no change and skip duplicate events
-                this.apiFiles[normalizedPath] = {
+                this.apiFiles[path] = {
                     apiPb: yaml.parse(JSON.stringify(apiPb)),
                     stepPathMap,
                     scopeId,
                 };
                 // TODO(george): as an optimization, we could update the memory snapshot of the file that SyncService is holding
-                const apiDir = nodePath.dirname(path);
                 await this.fsOperationQueue.enqueue(async () => {
-                    await writeApiFiles({ apiPb }, "api", apiDir, false, [], [], { extractLargeSourceFiles: true, minLinesForExtraction: 1 }, new Set(Object.keys(this.apiFiles)), stepPathMap);
+                    await writeApiFiles({ apiPb }, "api", path.split("/").slice(0, -1).join("/"), false, [], [], { extractLargeSourceFiles: true, minLinesForExtraction: 1 }, new Set(Object.keys(this.apiFiles)), stepPathMap);
                 });
                 break;
             }
@@ -635,7 +679,7 @@ export class FileSystemManager extends TracedEventEmitter {
         }
     }
     readFile(path) {
-        return this.tsFiles[normalizePath(path)];
+        return this.tsFiles[path];
     }
     async setFileContents(path, contents) {
         const logger = getLogger();
@@ -660,15 +704,14 @@ export class FileSystemManager extends TracedEventEmitter {
     }
     getLocalBindingEntities(path) {
         const logger = getLogger();
-        const normalizedPath = normalizePath(path);
         const files = this.sourceTracker?.getCurrentFiles();
-        if (!files || !files[normalizedPath]) {
-            logger.warn(`File not found in source tracker for local binding entities: ${normalizedPath}`);
+        if (!files || !files[path]) {
+            logger.warn(`File not found in source tracker for local binding entities: ${path}`);
             return [];
         }
-        const ast = files[normalizedPath].ast;
+        const ast = files[path].ast;
         if (!ast) {
-            logger.warn(`No AST found for file in source tracker for local binding entities: ${normalizedPath}`);
+            logger.warn(`No AST found for file in source tracker for local binding entities: ${path}`);
             return [];
         }
         const localBindingEntities = new Set();
@@ -687,7 +730,7 @@ export class FileSystemManager extends TracedEventEmitter {
         return Array.from(localBindingEntities);
     }
     getPageRootNodes(filePath) {
-        const scopeFilePath = normalizePath(nodePath.join(nodePath.dirname(filePath), "index.tsx"));
+        const scopeFilePath = path.join(path.dirname(filePath), "index.tsx");
         return this.getRootNodesForFile(scopeFilePath);
     }
     getAppRootNodes() {
@@ -707,8 +750,8 @@ export class FileSystemManager extends TracedEventEmitter {
             let resolvedPath = await getFullImportPath(localPath);
             // Fallback: manually resolve relative paths if Vite resolver fails
             if (!resolvedPath && localPath.startsWith(".")) {
-                const currentDir = nodePath.dirname(filePath);
-                const potentialPath = nodePath.resolve(currentDir, localPath);
+                const currentDir = path.dirname(filePath);
+                const potentialPath = path.resolve(currentDir, localPath);
                 // Try with different extensions
                 const extensions = [
                     "/index.tsx",
@@ -738,24 +781,22 @@ export class FileSystemManager extends TracedEventEmitter {
         return importedFiles;
     }
     async getRootNodesForFile(filePath) {
-        const normalizedPath = normalizePath(filePath);
-        const currentFile = this.sourceTracker?.getCurrentFiles()[normalizedPath];
+        const currentFile = this.sourceTracker?.getCurrentFiles()[filePath];
         if (!currentFile) {
             return undefined;
         }
         const allFiles = this.sourceTracker?.getCurrentFiles() ?? {};
         // Collect all imported files recursively (including transitive imports)
-        const importedNamesToFiles = await this.collectAllImports(normalizedPath, allFiles);
+        const importedNamesToFiles = await this.collectAllImports(filePath, allFiles);
         // Get roots from imported files (custom components)
         const importedRoots = Object.entries(importedNamesToFiles).flatMap(([filePath, file]) => getRootNodes(filePath, file));
         // Get roots from the current file
-        const roots = getRootNodes(normalizedPath, currentFile);
+        const roots = getRootNodes(filePath, currentFile);
         return [...roots, ...importedRoots];
     }
     getScope(filePath, fallback) {
         // Since we no longer use scope.ts files, generate scope info from file path. Pages retain page scope, everything else is App.
-        const normalizedPath = normalizePath(filePath);
-        const scopeName = getScopeNameFromPath(normalizedPath);
+        const scopeName = getScopeNameFromPath(filePath);
         if (!scopeName) {
             if (fallback) {
                 return {
@@ -931,8 +972,8 @@ export class FileSystemManager extends TracedEventEmitter {
         if (!this.rootDir) {
             throw new Error("Root directory not set");
         }
-        // no leading slash, normalize to forward slashes for routes (Windows compatibility)
-        return normalizePath(nodePath.relative(nodePath.join(this.rootDir, PAGES_DIRECTORY), filePath));
+        // no leading slash
+        return path.relative(path.join(this.rootDir, PAGES_DIRECTORY), filePath);
     }
     // MARK: API operations
     handleUpdateApi = async (payload) => {
@@ -949,8 +990,7 @@ export class FileSystemManager extends TracedEventEmitter {
             throw new Error("Root directory not set");
         }
         const apiFilePath = getApiFilePath(this.rootDir, apiName);
-        const normalizedApiFilePath = normalizePath(apiFilePath);
-        const apiDir = nodePath.dirname(normalizedApiFilePath);
+        const apiDir = path.dirname(apiFilePath);
         try {
             const stats = await fs.stat(apiDir);
             if (!stats.isDirectory()) {
@@ -977,12 +1017,11 @@ export class FileSystemManager extends TracedEventEmitter {
         const deletedApis = [];
         for (const { apiName } of apis) {
             const apiFilePath = getApiFilePath(rootDir, apiName);
-            const normalizedApiFilePath = normalizePath(apiFilePath);
-            const api = this.apiFiles[normalizedApiFilePath];
+            const api = this.apiFiles[apiFilePath];
             if (!api || !this.sourceTracker) {
                 continue;
             }
-            const apiDir = nodePath.dirname(apiFilePath);
+            const apiDir = path.dirname(apiFilePath);
             try {
                 await this.fsOperationQueue.enqueue(async () => {
                     const stats = await fs.stat(apiDir);
@@ -990,7 +1029,7 @@ export class FileSystemManager extends TracedEventEmitter {
                         await fs.rmdir(apiDir, { recursive: true });
                     }
                 });
-                delete this.apiFiles[normalizedApiFilePath];
+                delete this.apiFiles[apiFilePath];
                 const scopeId = this.sourceTracker.deleteApi({
                     apiName,
                 });
@@ -1015,16 +1054,15 @@ export class FileSystemManager extends TracedEventEmitter {
         if (!this.rootDir) {
             throw new Error("Root directory not set");
         }
-        const existingApiFolder = nodePath.join(this.rootDir, "apis", oldName);
-        const newApiFolder = nodePath.join(this.rootDir, "apis", newName);
-        const apiFilePath = nodePath.join(existingApiFolder, "api.yaml");
-        const normalizedApiFilePath = normalizePath(apiFilePath);
-        const apiDef = this.apiFiles[normalizedApiFilePath];
+        const existingApiFolder = path.join(this.rootDir, "apis", oldName);
+        const newApiFolder = path.join(this.rootDir, "apis", newName);
+        const apiFilePath = path.join(existingApiFolder, "api.yaml");
+        const apiDef = this.apiFiles[apiFilePath];
         if (!apiDef) {
             throw new Error(`API ${oldName} not found`);
         }
         const otherAPIs = structuredClone(Object.keys(this.apiFiles)
-            .filter((path) => path !== normalizedApiFilePath)
+            .filter((path) => path !== apiFilePath)
             .map((path) => ({
             api: { apiPb: this.apiFiles[path]?.apiPb },
             filePath: path,
@@ -1039,9 +1077,9 @@ export class FileSystemManager extends TracedEventEmitter {
         apiDef.apiPb.metadata.name = newName;
         await fs.rename(existingApiFolder, newApiFolder);
         const scopeId = getScopeIdFromName("App");
-        delete this.apiFiles[normalizedApiFilePath];
+        delete this.apiFiles[apiFilePath];
         // not waiting because we are queueing the write further down
-        void this.writeFile(nodePath.join(newApiFolder, "api.yaml"), yaml.stringify(apiDef.apiPb), "api");
+        void this.writeFile(path.join(newApiFolder, "api.yaml"), yaml.stringify(apiDef.apiPb), "api");
         this.watcher?.add(existingApiFolder);
         this.watcher?.add(newApiFolder);
         const changes = (await this.sourceTracker?.getAndFlushChanges()) ?? [];
@@ -1069,12 +1107,11 @@ export class FileSystemManager extends TracedEventEmitter {
         }));
     };
     async removeApiData(filePath) {
-        const normalizedPath = normalizePath(filePath);
-        const api = this.apiFiles[normalizedPath];
+        const api = this.apiFiles[filePath];
         if (!api) {
             return;
         }
-        delete this.apiFiles[normalizedPath];
+        delete this.apiFiles[filePath];
         this.sourceTracker?.deleteApi({
             apiName: api.apiPb.metadata.name,
         });
@@ -1133,10 +1170,9 @@ export class FileSystemManager extends TracedEventEmitter {
         let yamlPath = filePath;
         if (fileType.type === "python-api-step" ||
             fileType.type === "js-api-step") {
-            const apiFolderPath = nodePath.dirname(filePath);
-            yamlPath = nodePath.join(apiFolderPath, "api.yaml");
+            const apiFolderPath = filePath.split("/").slice(0, -1).join("/");
+            yamlPath = path.join(apiFolderPath, "api.yaml");
         }
-        const normalizedYamlPath = normalizePath(yamlPath);
         const logger = getLogger();
         logger.info(`Processing API file update: ${yamlPath}`);
         try {
@@ -1147,9 +1183,9 @@ export class FileSystemManager extends TracedEventEmitter {
             }
             logger.info(`API structure is valid: ${yamlPath}`);
             const parsedData = { apiPb: apiContent?.api };
-            if (normalizedYamlPath in this.apiFiles &&
-                isEqual(this.apiFiles[normalizedYamlPath]?.apiPb, parsedData.apiPb)) {
-                logger.info(`No changes detected in API: ${normalizedYamlPath}`);
+            if (yamlPath in this.apiFiles &&
+                isEqual(this.apiFiles[yamlPath]?.apiPb, parsedData.apiPb)) {
+                logger.info(`No changes detected in API: ${yamlPath}`);
                 return;
             }
             const { updatedApi, isNewApi } = this.updateInternalApiData({
@@ -1215,35 +1251,28 @@ export class MockFileSyncManager extends FileSystemManager {
     }
     async writeFile(path, content, kind) {
         await this.fsOperationQueue.enqueue(async () => {
-            const normalizedPath = normalizePath(path);
             if (kind === "ts") {
-                this.tsFiles[normalizedPath] = content;
+                this.tsFiles[path] = content;
             }
             else {
-                this.apiFiles[normalizedPath] = {
+                this.apiFiles[path] = {
                     apiPb: yaml.parse(content),
                     stepPathMap: {},
                     scopeId: getScopeIdFromName("App"),
                 };
             }
             // Notify subscribers
-            this.emit("fileChanged", normalizedPath, content, true);
+            this.emit("fileChanged", path, content, true);
         });
     }
     // Helper methods for testing
     mockFileChange(path, content) {
-        const normalizedPath = normalizePath(path);
-        this.tsFiles[normalizedPath] = content;
-        this.emit("fileChanged", normalizedPath, content, true);
+        this.tsFiles[path] = content;
+        this.emit("fileChanged", path, content, true);
     }
     handleUpdateApi = async (payload) => {
         const apiName = payload.api.apiPb.metadata.name;
-        if (!this.rootDir) {
-            throw new Error("Root directory not set");
-        }
-        const apiFilePath = getApiFilePath(this.rootDir, apiName);
-        const normalizedApiFilePath = normalizePath(apiFilePath);
-        this.apiFiles[normalizedApiFilePath] = {
+        this.apiFiles[apiName] = {
             ...payload.api,
             stepPathMap: {},
             scopeId: payload.scopeId,
@@ -1274,9 +1303,7 @@ async function readFile(path) {
     }
 }
 async function readFiles(dir) {
-    const files = await glob("**/*.{tsx,yaml,ts}", {
-        cwd: dir,
-        absolute: true,
+    return await glob(path.join(dir, "**/*.{tsx,yaml,ts}"), {
         ignore: [
             "node_modules/**",
             "dist/**",
@@ -1285,10 +1312,8 @@ async function readFiles(dir) {
             `./${getLegacyComponentsFolder()}/**`,
         ],
     });
-    // Normalize paths to use forward slashes on all platforms (Windows returns backslashes)
-    return files.map((file) => normalizePath(file));
 }
-const getMergedApiContent = async (filePath) => {
-    return readAppApiYamlFile(nodePath.dirname(filePath));
+const getMergedApiContent = async (path) => {
+    return readAppApiYamlFile(path.split("/").slice(0, -1).join("/"));
 };
 //# sourceMappingURL=file-system-manager.js.map