lwc-convert 1.6.1 → 1.7.0

package/dist/index.js

@@ -55,8 +55,8 @@ var init_esm_shims = __esm({
 import { readFileSync } from "fs";
 import { join } from "path";
 function getPackageVersion() {
-  if ("1.6.1") {
-    return "1.6.1";
+  if ("1.7.0") {
+    return "1.7.0";
   }
   try {
     const possiblePaths = [
@@ -229,6 +229,26 @@ ${COLORS.dim}  ${message}${COLORS.reset}`);
       blank() {
         console.log("");
       }
+      // Success toast for completed operations
+      successToast(title, details, outputPath) {
+        console.log("");
+        console.log(`${COLORS.green}  \u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E${COLORS.reset}`);
+        console.log(`${COLORS.green}  \u2502${COLORS.reset}                                         ${COLORS.green}\u2502${COLORS.reset}`);
+        console.log(`${COLORS.green}  \u2502${COLORS.reset}            ${COLORS.bright}\u2728 Success! \u2728${COLORS.reset}               ${COLORS.green}\u2502${COLORS.reset}`);
+        console.log(`${COLORS.green}  \u2502${COLORS.reset}                                         ${COLORS.green}\u2502${COLORS.reset}`);
+        details.forEach((detail) => {
+          const padded = detail.padEnd(38);
+          console.log(`${COLORS.green}  \u2502${COLORS.reset}  ${padded} ${COLORS.green}\u2502${COLORS.reset}`);
+        });
+        if (outputPath) {
+          console.log(`${COLORS.green}  \u2502${COLORS.reset}                                         ${COLORS.green}\u2502${COLORS.reset}`);
+          const pathText = `\u{1F4C1} ${outputPath}`.padEnd(38);
+          console.log(`${COLORS.green}  \u2502${COLORS.reset}  ${pathText} ${COLORS.green}\u2502${COLORS.reset}`);
+        }
+        console.log(`${COLORS.green}  \u2502${COLORS.reset}                                         ${COLORS.green}\u2502${COLORS.reset}`);
+        console.log(`${COLORS.green}  \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F${COLORS.reset}`);
+        console.log("");
+      }
     };
     logger = new Logger();
   }
@@ -648,13 +668,13 @@ function extractFunctionBody(node, source) {
   }
   return "";
 }
-function parseAttributeAccess(path16) {
-  const callee = path16.node.callee;
+function parseAttributeAccess(path17) {
+  const callee = path17.node.callee;
   if (!t.isMemberExpression(callee)) return null;
   const property = callee.property;
   if (!t.isIdentifier(property)) return null;
   if (property.name !== "get" && property.name !== "set") return null;
-  const args2 = path16.node.arguments;
+  const args2 = path17.node.arguments;
   if (args2.length === 0) return null;
   const firstArg = args2[0];
   if (!t.isStringLiteral(firstArg)) return null;
@@ -667,8 +687,8 @@ function parseAttributeAccess(path16) {
     operation
   };
 }
-function parseServerCall(path16, _source) {
-  const callee = path16.node.callee;
+function parseServerCall(path17, _source) {
+  const callee = path17.node.callee;
   if (t.isMemberExpression(callee) && t.isIdentifier(callee.object, { name: "$A" }) && t.isIdentifier(callee.property, { name: "enqueueAction" })) {
     return {
       actionName: "enqueueAction",
@@ -678,7 +698,7 @@ function parseServerCall(path16, _source) {
   if (t.isMemberExpression(callee)) {
     const property = callee.property;
     if (t.isIdentifier(property, { name: "get" })) {
-      const args2 = path16.node.arguments;
+      const args2 = path17.node.arguments;
       if (args2.length > 0 && t.isStringLiteral(args2[0])) {
         const value = args2[0].value;
         if (value.startsWith("c.")) {
@@ -693,17 +713,17 @@ function parseServerCall(path16, _source) {
   }
   return null;
 }
-function parseHelperCall(path16) {
-  const callee = path16.node.callee;
+function parseHelperCall(path17) {
+  const callee = path17.node.callee;
   if (t.isMemberExpression(callee) && t.isIdentifier(callee.object, { name: "helper" }) && t.isIdentifier(callee.property)) {
     return callee.property.name;
   }
   return null;
 }
-function parseEventFire(path16) {
-  const callee = path16.node.callee;
+function parseEventFire(path17) {
+  const callee = path17.node.callee;
   if (t.isMemberExpression(callee) && t.isIdentifier(callee.object, { name: "$A" }) && t.isIdentifier(callee.property, { name: "get" })) {
-    const args2 = path16.node.arguments;
+    const args2 = path17.node.arguments;
     if (args2.length > 0 && t.isStringLiteral(args2[0])) {
       const value = args2[0].value;
       if (value.startsWith("e.")) {
@@ -712,7 +732,7 @@ function parseEventFire(path16) {
     }
   }
   if (t.isMemberExpression(callee) && t.isIdentifier(callee.property, { name: "getEvent" })) {
-    const args2 = path16.node.arguments;
+    const args2 = path17.node.arguments;
     if (args2.length > 0 && t.isStringLiteral(args2[0])) {
       return args2[0].value;
     }
@@ -743,11 +763,11 @@ function parseAuraController(source) {
     return result;
   }
   traverse(ast, {
-    ObjectExpression(path16) {
-      if (path16.parent.type === "VariableDeclarator" && t.isIdentifier(path16.parent.id, {
+    ObjectExpression(path17) {
+      if (path17.parent.type === "VariableDeclarator" && t.isIdentifier(path17.parent.id, {
         name: "__auraController"
       })) {
-        for (const prop of path16.node.properties) {
+        for (const prop of path17.node.properties) {
           if (t.isObjectProperty(prop) && t.isIdentifier(prop.key) && t.isFunctionExpression(prop.value)) {
             const funcName = prop.key.name;
             const funcExpr = prop.value;
@@ -771,7 +791,7 @@ function parseAuraController(source) {
               (p2) => p2 === "event" || p2 === "evt"
             );
             funcDef.hasHelper = funcDef.params.some((p2) => p2 === "helper");
-            const funcPath = path16.get("properties").find((propPath) => {
+            const funcPath = path17.get("properties").find((propPath) => {
               const propNode = propPath.node;
               return t.isObjectProperty(propNode) && t.isIdentifier(propNode.key, { name: funcName });
             });
@@ -855,11 +875,11 @@ function parseAuraHelper(source) {
   }
   const helperFunctionNames = /* @__PURE__ */ new Set();
   traverse2(ast, {
-    ObjectExpression(path16) {
-      if (path16.parent.type === "VariableDeclarator" && t2.isIdentifier(path16.parent.id, {
+    ObjectExpression(path17) {
+      if (path17.parent.type === "VariableDeclarator" && t2.isIdentifier(path17.parent.id, {
         name: "__auraHelper"
       })) {
-        for (const prop of path16.node.properties) {
+        for (const prop of path17.node.properties) {
           if (t2.isObjectProperty(prop) && t2.isIdentifier(prop.key)) {
             helperFunctionNames.add(prop.key.name);
           }
@@ -868,11 +888,11 @@ function parseAuraHelper(source) {
     }
   });
   traverse2(ast, {
-    ObjectExpression(path16) {
-      if (path16.parent.type === "VariableDeclarator" && t2.isIdentifier(path16.parent.id, {
+    ObjectExpression(path17) {
+      if (path17.parent.type === "VariableDeclarator" && t2.isIdentifier(path17.parent.id, {
         name: "__auraHelper"
       })) {
-        for (const prop of path16.node.properties) {
+        for (const prop of path17.node.properties) {
           if (t2.isObjectProperty(prop) && t2.isIdentifier(prop.key) && t2.isFunctionExpression(prop.value)) {
             const funcName = prop.key.name;
             const funcExpr = prop.value;
@@ -888,7 +908,7 @@ function parseAuraHelper(source) {
             funcDef.hasComponent = funcDef.params.some(
               (p2) => p2 === "component" || p2 === "cmp"
             );
-            const funcPath = path16.get("properties").find((propPath) => {
+            const funcPath = path17.get("properties").find((propPath) => {
               const propNode = propPath.node;
               return t2.isObjectProperty(propNode) && t2.isIdentifier(propNode.key, { name: funcName });
             });
@@ -6543,29 +6563,80 @@ var init_full_conversion = __esm({
   }
 });
 
-// src/utils/path-resolver.ts
+// src/utils/project-detector.ts
 import * as path3 from "path";
 import fs2 from "fs-extra";
+async function findProjectRoot(startDir = process.cwd()) {
+  let currentDir = path3.resolve(startDir);
+  const root = path3.parse(currentDir).root;
+  while (currentDir !== root) {
+    for (const marker of PROJECT_MARKERS) {
+      const markerPath = path3.join(currentDir, marker);
+      if (await fs2.pathExists(markerPath)) {
+        if (marker === "sfdx-project.json") {
+          return currentDir;
+        }
+        if (marker === "force-app") {
+          const sfdxPath = path3.join(currentDir, "sfdx-project.json");
+          if (await fs2.pathExists(sfdxPath)) {
+            return currentDir;
+          }
+        }
+      }
+    }
+    const parentDir = path3.dirname(currentDir);
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+  return null;
+}
+async function ensureProjectRoot() {
+  const cwd = process.cwd();
+  const projectRoot = await findProjectRoot(cwd);
+  if (projectRoot && projectRoot !== cwd) {
+    process.chdir(projectRoot);
+    return { root: projectRoot, changed: true };
+  }
+  return { root: cwd, changed: false };
+}
+var PROJECT_MARKERS;
+var init_project_detector = __esm({
+  "src/utils/project-detector.ts"() {
+    "use strict";
+    init_esm_shims();
+    PROJECT_MARKERS = [
+      "sfdx-project.json",
+      "force-app",
+      "package.json"
+      // fallback
+    ];
+  }
+});
+
+// src/utils/path-resolver.ts
+import * as path4 from "path";
+import fs3 from "fs-extra";
 function isFullPath(inputPath) {
-  return inputPath.includes("/") || inputPath.includes("\\") || inputPath.startsWith(".") || path3.isAbsolute(inputPath);
+  return inputPath.includes("/") || inputPath.includes("\\") || inputPath.startsWith(".") || path4.isAbsolute(inputPath);
 }
 async function resolveAuraPath(input) {
+  const projectRoot = await findProjectRoot();
+  const cwd = projectRoot || process.cwd();
   if (isFullPath(input)) {
-    const resolved = path3.resolve(input);
+    const resolved = path4.resolve(input);
     return {
-      found: await fs2.pathExists(resolved),
+      found: await fs3.pathExists(resolved),
       path: resolved
     };
   }
   const componentName = input;
-  const cwd = process.cwd();
   const searchedLocations = [];
   for (const searchPath of AURA_SEARCH_PATHS) {
-    const fullPath = path3.join(cwd, searchPath, componentName);
+    const fullPath = path4.join(cwd, searchPath, componentName);
     searchedLocations.push(fullPath);
-    if (await fs2.pathExists(fullPath)) {
-      const cmpFile = path3.join(fullPath, `${componentName}.cmp`);
-      if (await fs2.pathExists(cmpFile)) {
+    if (await fs3.pathExists(fullPath)) {
+      const cmpFile = path4.join(fullPath, `${componentName}.cmp`);
+      if (await fs3.pathExists(cmpFile)) {
         return {
           found: true,
           path: fullPath,
@@ -6575,8 +6646,8 @@ async function resolveAuraPath(input) {
     }
   }
   for (const searchPath of AURA_SEARCH_PATHS) {
-    const basePath = path3.join(cwd, searchPath);
-    if (await fs2.pathExists(basePath)) {
+    const basePath = path4.join(cwd, searchPath);
+    if (await fs3.pathExists(basePath)) {
       const found = await searchForComponent(basePath, componentName, ".cmp");
       if (found) {
         return {
@@ -6594,46 +6665,47 @@ async function resolveAuraPath(input) {
   };
 }
 async function resolveVfPath(input) {
+  const projectRoot = await findProjectRoot();
+  const cwd = projectRoot || process.cwd();
   if (isFullPath(input)) {
-    const resolved = path3.resolve(input);
+    const resolved = path4.resolve(input);
     return {
-      found: await fs2.pathExists(resolved),
+      found: await fs3.pathExists(resolved),
       path: resolved
     };
   }
-  const cwd = process.cwd();
   const searchedLocations = [];
   const hasPageExtension = input.endsWith(".page");
   const hasComponentExtension = input.endsWith(".component");
   if (hasPageExtension) {
     for (const searchPath of VF_PAGE_SEARCH_PATHS) {
-      const fullPath = path3.join(cwd, searchPath, input);
+      const fullPath = path4.join(cwd, searchPath, input);
       searchedLocations.push(fullPath);
-      if (await fs2.pathExists(fullPath)) {
+      if (await fs3.pathExists(fullPath)) {
         return { found: true, path: fullPath, searchedLocations };
       }
     }
   } else if (hasComponentExtension) {
     for (const searchPath of VF_COMPONENT_SEARCH_PATHS) {
-      const fullPath = path3.join(cwd, searchPath, input);
+      const fullPath = path4.join(cwd, searchPath, input);
       searchedLocations.push(fullPath);
-      if (await fs2.pathExists(fullPath)) {
+      if (await fs3.pathExists(fullPath)) {
         return { found: true, path: fullPath, searchedLocations };
       }
     }
   } else {
     const baseName = input;
     for (const searchPath of VF_PAGE_SEARCH_PATHS) {
-      const fullPath = path3.join(cwd, searchPath, `${baseName}.page`);
+      const fullPath = path4.join(cwd, searchPath, `${baseName}.page`);
       searchedLocations.push(fullPath);
-      if (await fs2.pathExists(fullPath)) {
+      if (await fs3.pathExists(fullPath)) {
         return { found: true, path: fullPath, searchedLocations };
       }
     }
     for (const searchPath of VF_COMPONENT_SEARCH_PATHS) {
-      const fullPath = path3.join(cwd, searchPath, `${baseName}.component`);
+      const fullPath = path4.join(cwd, searchPath, `${baseName}.component`);
       searchedLocations.push(fullPath);
-      if (await fs2.pathExists(fullPath)) {
+      if (await fs3.pathExists(fullPath)) {
         return { found: true, path: fullPath, searchedLocations };
       }
     }
@@ -6645,10 +6717,12 @@ async function resolveVfPath(input) {
   };
 }
 async function resolveApexPath(input) {
+  const projectRoot = await findProjectRoot();
+  const cwd = projectRoot || process.cwd();
   if (isFullPath(input)) {
-    const resolved = path3.resolve(input);
+    const resolved = path4.resolve(input);
     return {
-      found: await fs2.pathExists(resolved),
+      found: await fs3.pathExists(resolved),
       path: resolved
     };
   }
@@ -6656,12 +6730,11 @@ async function resolveApexPath(input) {
   if (!className.endsWith(".cls")) {
     className = `${className}.cls`;
   }
-  const cwd = process.cwd();
   const searchedLocations = [];
   for (const searchPath of APEX_SEARCH_PATHS) {
-    const fullPath = path3.join(cwd, searchPath, className);
+    const fullPath = path4.join(cwd, searchPath, className);
     searchedLocations.push(fullPath);
-    if (await fs2.pathExists(fullPath)) {
+    if (await fs3.pathExists(fullPath)) {
       return {
         found: true,
         path: fullPath,
@@ -6677,18 +6750,18 @@ async function resolveApexPath(input) {
 }
 async function searchForComponent(baseDir, componentName, extension) {
   try {
-    const entries = await fs2.readdir(baseDir, { withFileTypes: true });
+    const entries = await fs3.readdir(baseDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (entry.name === componentName) {
-          const componentPath = path3.join(baseDir, entry.name);
-          const mainFile = path3.join(componentPath, `${componentName}${extension}`);
-          if (await fs2.pathExists(mainFile)) {
+          const componentPath = path4.join(baseDir, entry.name);
+          const mainFile = path4.join(componentPath, `${componentName}${extension}`);
+          if (await fs3.pathExists(mainFile)) {
             return componentPath;
           }
         }
         const subResult = await searchForComponent(
-          path3.join(baseDir, entry.name),
+          path4.join(baseDir, entry.name),
           componentName,
           extension
         );
@@ -6702,13 +6775,14 @@ async function searchForComponent(baseDir, componentName, extension) {
   return null;
 }
 function formatSearchLocations(locations, cwd) {
-  return locations.map((loc) => `  - ${path3.relative(cwd, loc) || loc}`).join("\n");
+  return locations.map((loc) => `  - ${path4.relative(cwd, loc) || loc}`).join("\n");
 }
 var AURA_SEARCH_PATHS, VF_PAGE_SEARCH_PATHS, VF_COMPONENT_SEARCH_PATHS, APEX_SEARCH_PATHS;
 var init_path_resolver = __esm({
   "src/utils/path-resolver.ts"() {
     "use strict";
     init_esm_shims();
+    init_project_detector();
     AURA_SEARCH_PATHS = [
       "force-app/main/default/aura",
       "src/aura",
@@ -6737,8 +6811,8 @@ var init_path_resolver = __esm({
 });
 
 // src/utils/session-store.ts
-import * as fs3 from "fs";
-import * as path4 from "path";
+import * as fs4 from "fs";
+import * as path5 from "path";
 import * as os from "os";
 var SESSIONS_BASE_DIR, ACTIVE_SESSION_FILE, SESSION_EXPIRY_MS, SessionStore, sessionStore;
 var init_session_store = __esm({
@@ -6746,8 +6820,8 @@ var init_session_store = __esm({
     "use strict";
     init_esm_shims();
     init_logger();
-    SESSIONS_BASE_DIR = path4.join(os.tmpdir(), "lwc-convert-sessions");
-    ACTIVE_SESSION_FILE = path4.join(SESSIONS_BASE_DIR, "active-session.json");
+    SESSIONS_BASE_DIR = path5.join(os.tmpdir(), "lwc-convert-sessions");
+    ACTIVE_SESSION_FILE = path5.join(SESSIONS_BASE_DIR, "active-session.json");
     SESSION_EXPIRY_MS = 4 * 60 * 60 * 1e3;
     SessionStore = class {
       sessionId = "";
@@ -6763,22 +6837,22 @@ var init_session_store = __esm({
        */
       async tryLoadExistingSession() {
         try {
-          if (!fs3.existsSync(ACTIVE_SESSION_FILE)) {
+          if (!fs4.existsSync(ACTIVE_SESSION_FILE)) {
             return false;
           }
           const activeInfo = JSON.parse(
-            await fs3.promises.readFile(ACTIVE_SESSION_FILE, "utf-8")
+            await fs4.promises.readFile(ACTIVE_SESSION_FILE, "utf-8")
           );
           const lastActivity = new Date(activeInfo.lastActivityAt).getTime();
           if (Date.now() - lastActivity > SESSION_EXPIRY_MS) {
             logger.debug("Previous session expired, starting new session");
             try {
-              await fs3.promises.rm(activeInfo.sessionDir, { recursive: true, force: true });
+              await fs4.promises.rm(activeInfo.sessionDir, { recursive: true, force: true });
             } catch {
             }
             return false;
           }
-          if (!fs3.existsSync(activeInfo.sessionDir)) {
+          if (!fs4.existsSync(activeInfo.sessionDir)) {
             return false;
           }
           this.sessionId = activeInfo.sessionId;
@@ -6797,13 +6871,13 @@ var init_session_store = __esm({
        */
       async loadConversions() {
         try {
-          const conversionsDir = path4.join(this.sessionDir, "conversions");
-          if (!fs3.existsSync(conversionsDir)) return;
-          const files = await fs3.promises.readdir(conversionsDir);
+          const conversionsDir = path5.join(this.sessionDir, "conversions");
+          if (!fs4.existsSync(conversionsDir)) return;
+          const files = await fs4.promises.readdir(conversionsDir);
           for (const file of files) {
             if (file.endsWith(".json")) {
-              const content = await fs3.promises.readFile(
-                path4.join(conversionsDir, file),
+              const content = await fs4.promises.readFile(
+                path5.join(conversionsDir, file),
                 "utf-8"
               );
               const record = JSON.parse(content);
@@ -6823,20 +6897,20 @@ var init_session_store = __esm({
        */
       async createNewSession() {
         this.sessionId = `lwc-convert-${Date.now()}-${Math.random().toString(36).substring(7)}`;
-        this.sessionDir = path4.join(SESSIONS_BASE_DIR, this.sessionId);
+        this.sessionDir = path5.join(SESSIONS_BASE_DIR, this.sessionId);
         this.startedAt = /* @__PURE__ */ new Date();
-        await fs3.promises.mkdir(this.sessionDir, { recursive: true });
-        await fs3.promises.mkdir(path4.join(this.sessionDir, "conversions"), { recursive: true });
-        await fs3.promises.mkdir(path4.join(this.sessionDir, "patterns"), { recursive: true });
-        await fs3.promises.mkdir(path4.join(this.sessionDir, "tests"), { recursive: true });
+        await fs4.promises.mkdir(this.sessionDir, { recursive: true });
+        await fs4.promises.mkdir(path5.join(this.sessionDir, "conversions"), { recursive: true });
+        await fs4.promises.mkdir(path5.join(this.sessionDir, "patterns"), { recursive: true });
+        await fs4.promises.mkdir(path5.join(this.sessionDir, "tests"), { recursive: true });
         const sessionInfo = {
           sessionId: this.sessionId,
           startedAt: this.startedAt.toISOString(),
           platform: os.platform(),
           nodeVersion: process.version
         };
-        await fs3.promises.writeFile(
-          path4.join(this.sessionDir, "session.json"),
+        await fs4.promises.writeFile(
+          path5.join(this.sessionDir, "session.json"),
           JSON.stringify(sessionInfo, null, 2)
         );
         logger.debug(`Created new session: ${this.sessionId}`);
@@ -6851,8 +6925,8 @@ var init_session_store = __esm({
           startedAt: this.startedAt.toISOString(),
           lastActivityAt: (/* @__PURE__ */ new Date()).toISOString()
         };
-        await fs3.promises.mkdir(SESSIONS_BASE_DIR, { recursive: true });
-        await fs3.promises.writeFile(
+        await fs4.promises.mkdir(SESSIONS_BASE_DIR, { recursive: true });
+        await fs4.promises.writeFile(
           ACTIVE_SESSION_FILE,
           JSON.stringify(activeInfo, null, 2)
         );
@@ -6914,10 +6988,10 @@ var init_session_store = __esm({
         this.conversions.push(record);
         this.updatePatternLibrary(record.patterns);
         try {
-          const conversionFile = path4.join(this.sessionDir, "conversions", `${record.id}.json`);
-          await fs3.promises.writeFile(conversionFile, JSON.stringify(record, null, 2));
-          const testFile = path4.join(this.sessionDir, "tests", `${targetName}-comparison.json`);
-          await fs3.promises.writeFile(testFile, JSON.stringify({
+          const conversionFile = path5.join(this.sessionDir, "conversions", `${record.id}.json`);
+          await fs4.promises.writeFile(conversionFile, JSON.stringify(record, null, 2));
+          const testFile = path5.join(this.sessionDir, "tests", `${targetName}-comparison.json`);
+          await fs4.promises.writeFile(testFile, JSON.stringify({
             ...testComparison,
             conversionId: record.id,
             timestamp: record.timestamp
@@ -7031,8 +7105,8 @@ var init_session_store = __esm({
           }
         }
         try {
-          const conversionFile = path4.join(this.sessionDir, "conversions", `${conversionId}.json`);
-          await fs3.promises.writeFile(conversionFile, JSON.stringify(conversion, null, 2));
+          const conversionFile = path5.join(this.sessionDir, "conversions", `${conversionId}.json`);
+          await fs4.promises.writeFile(conversionFile, JSON.stringify(conversion, null, 2));
           await this.saveSessionSummary();
         } catch (error) {
           logger.debug(`Failed to update conversion: ${error.message}`);
@@ -7063,12 +7137,12 @@ var init_session_store = __esm({
       async saveSessionSummary() {
         const summary = this.getSessionSummary();
         try {
-          await fs3.promises.writeFile(
-            path4.join(this.sessionDir, "summary.json"),
+          await fs4.promises.writeFile(
+            path5.join(this.sessionDir, "summary.json"),
             JSON.stringify(summary, null, 2)
           );
-          await fs3.promises.writeFile(
-            path4.join(this.sessionDir, "patterns", "library.json"),
+          await fs4.promises.writeFile(
+            path5.join(this.sessionDir, "patterns", "library.json"),
             JSON.stringify(Array.from(this.patternLibrary.values()), null, 2)
           );
         } catch (error) {
@@ -7144,10 +7218,10 @@ All session data is stored in:
       async cleanup() {
         try {
           if (this.sessionDir) {
-            await fs3.promises.rm(this.sessionDir, { recursive: true, force: true });
+            await fs4.promises.rm(this.sessionDir, { recursive: true, force: true });
           }
-          if (fs3.existsSync(ACTIVE_SESSION_FILE)) {
-            await fs3.promises.unlink(ACTIVE_SESSION_FILE);
+          if (fs4.existsSync(ACTIVE_SESSION_FILE)) {
+            await fs4.promises.unlink(ACTIVE_SESSION_FILE);
           }
           this.conversions = [];
           this.patternLibrary.clear();
@@ -7190,8 +7264,8 @@ All session data is stored in:
 });
 
 // src/utils/preview-generator.ts
-import fs4 from "fs-extra";
-import * as path5 from "path";
+import fs5 from "fs-extra";
+import * as path6 from "path";
 function parseAttributes(tagContent) {
   const attrs = {};
   const attrRegex = /(\S+?)(?:=(?:"([^"]*)"|{([^}]*)})|(?=\s|>|$))/g;
@@ -7578,14 +7652,14 @@ function generatePreviewHtml(bundle, componentCss) {
 </html>`;
 }
 async function writePreviewFile(outputDir, bundle, dryRun = false) {
-  const previewPath = path5.join(outputDir, bundle.name, `${bundle.name}-preview.html`);
+  const previewPath = path6.join(outputDir, bundle.name, `${bundle.name}-preview.html`);
   const previewHtml = generatePreviewHtml(bundle, bundle.css);
   if (dryRun) {
     logger.info(`[DRY RUN] Would write preview: ${previewPath}`);
     return previewPath;
   }
-  await fs4.ensureDir(path5.dirname(previewPath));
-  await fs4.writeFile(previewPath, previewHtml, "utf-8");
+  await fs5.ensureDir(path6.dirname(previewPath));
+  await fs5.writeFile(previewPath, previewHtml, "utf-8");
   logger.file("CREATE", previewPath);
   return previewPath;
 }
@@ -7970,7 +8044,7 @@ __export(open_folder_exports, {
 import { exec } from "child_process";
 import * as os2 from "os";
 function openFolder(folderPath) {
-  return new Promise((resolve7, _reject) => {
+  return new Promise((resolve8, _reject) => {
     const platform3 = os2.platform();
     let command;
     switch (platform3) {
@@ -7987,9 +8061,9 @@ function openFolder(folderPath) {
     exec(command, (error) => {
       if (error) {
         logger.warn(`Could not open folder: ${error.message}`);
-        resolve7();
+        resolve8();
       } else {
-        resolve7();
+        resolve8();
       }
     });
   });
@@ -8007,8 +8081,12 @@ var aura_exports = {};
 __export(aura_exports, {
   convertAura: () => convertAura
 });
-import * as path6 from "path";
+import * as path7 from "path";
 async function convertAura(inputPath, options) {
+  const { root, changed } = await ensureProjectRoot();
+  if (changed) {
+    logger.success(`Found project root: ${root}`);
+  }
   const resolved = await resolveAuraPath(inputPath);
   if (!resolved.found) {
     const searchInfo = resolved.searchedLocations && resolved.searchedLocations.length > 0 ? `
@@ -8084,41 +8162,40 @@ Tip: You can provide just the component name (e.g., "AccountCard") or a full pat
   }
   logger.success(`Generated LWC: ${result.bundle.name}`);
   logger.step(7, "Writing output files...");
-  const outputDir = path6.resolve(options.output);
+  const outputDir = path7.resolve(options.output);
   const writtenFiles = await writeLwcBundle(outputDir, result.bundle, options.dryRun);
   if (result.notes.length > 0) {
     await writeConversionNotes(outputDir, result.bundle.name, result.notes, options.dryRun);
   }
   if (result.tests) {
-    const testDir = path6.join(outputDir, result.bundle.name, "__tests__");
-    const testFilePath = path6.join(testDir, result.tests.filename);
+    const testDir = path7.join(outputDir, result.bundle.name, "__tests__");
+    const testFilePath = path7.join(testDir, result.tests.filename);
     const { writeFile: writeFile2 } = await Promise.resolve().then(() => (init_file_io(), file_io_exports));
     await writeFile2(testFilePath, result.tests.content, options.dryRun);
   }
   if (result.behaviorSpec) {
-    const specFilePath = path6.join(outputDir, result.bundle.name, `${result.bundle.name}-behavior-spec.md`);
+    const specFilePath = path7.join(outputDir, result.bundle.name, `${result.bundle.name}-behavior-spec.md`);
     const { writeFile: writeFile2 } = await Promise.resolve().then(() => (init_file_io(), file_io_exports));
     await writeFile2(specFilePath, result.behaviorSpec, options.dryRun);
   }
   if (result.testComparison) {
     const { writeFile: writeFile2 } = await Promise.resolve().then(() => (init_file_io(), file_io_exports));
-    const testDir = path6.join(outputDir, result.bundle.name, "__tests__");
-    const beforeTestPath = path6.join(testDir, `${result.bundle.name}.before.spec.js`);
+    const testDir = path7.join(outputDir, result.bundle.name, "__tests__");
+    const beforeTestPath = path7.join(testDir, `${result.bundle.name}.before.spec.js`);
     await writeFile2(beforeTestPath, result.testComparison.beforeTestFile, options.dryRun);
-    const afterTestPath = path6.join(testDir, `${result.bundle.name}.after.test.js`);
+    const afterTestPath = path7.join(testDir, `${result.bundle.name}.after.test.js`);
     await writeFile2(afterTestPath, result.testComparison.afterTestFile, options.dryRun);
-    const comparisonReportPath = path6.join(outputDir, result.bundle.name, `${result.bundle.name}-test-comparison.md`);
+    const comparisonReportPath = path7.join(outputDir, result.bundle.name, `${result.bundle.name}-test-comparison.md`);
     await writeFile2(comparisonReportPath, result.testComparison.comparisonReport, options.dryRun);
   }
   logger.divider();
-  logger.success("Conversion complete!");
   if (result.testComparison) {
     const conversionRecord = await sessionStore.storeConversion(
       "aura",
       bundle.name,
       result.bundle.name,
       bundlePath,
-      path6.join(outputDir, result.bundle.name),
+      path7.join(outputDir, result.bundle.name),
       result.testComparison,
       result.warnings
     );
@@ -8128,14 +8205,21 @@ Tip: You can provide just the component name (e.g., "AccountCard") or a full pat
   if (result.tests) totalFiles++;
   if (result.behaviorSpec) totalFiles++;
   if (result.testComparison) totalFiles += 3;
+  logger.successToast(
+    "Conversion Complete",
+    [
+      `${bundle.name} \u2192 ${result.bundle.name}`,
+      `${totalFiles} files created`
+    ],
+    path7.join(outputDir, result.bundle.name)
+  );
   const sessionSummary = sessionStore.getSessionSummary();
   logger.summaryBox("Conversion Summary", [
     { label: "Component", value: `${bundle.name} \u2192 ${result.bundle.name}`, type: "success" },
     { label: "Files created", value: `${totalFiles}`, type: "info" },
     { label: "Behaviors mapped", value: `${result.testComparison?.behaviorTests.length || 0}`, type: "info" },
     { label: "Warnings", value: `${result.warnings.length}`, type: result.warnings.length > 0 ? "warn" : "success" },
-    { label: "Session conversions", value: `${sessionSummary.conversions}`, type: "info" },
-    { label: "Output", value: path6.join(outputDir, result.bundle.name), type: "info" }
+    { label: "Output", value: path7.join(outputDir, result.bundle.name), type: "info" }
   ]);
   if (result.warnings.length > 0) {
     if (options.verbose) {
@@ -8185,6 +8269,7 @@ var init_aura = __esm({
     init_path_resolver();
     init_session_store();
     init_preview_generator();
+    init_project_detector();
   }
 });
 
@@ -8686,8 +8771,12 @@ var vf_exports = {};
 __export(vf_exports, {
   convertVf: () => convertVf
 });
-import * as path7 from "path";
+import * as path8 from "path";
 async function convertVf(inputPath, options) {
+  const { root, changed } = await ensureProjectRoot();
+  if (changed) {
+    logger.success(`Found project root: ${root}`);
+  }
   const resolved = await resolveVfPath(inputPath);
   if (!resolved.found) {
     const searchInfo = resolved.searchedLocations && resolved.searchedLocations.length > 0 ? `
@@ -8793,18 +8882,26 @@ Tip: You can provide just the page name (e.g., "ContactList") or a full path (e.
   }
   logger.success(`Generated LWC: ${result.bundle.name}`);
   logger.step(6, "Writing output files...");
-  const outputDir = path7.resolve(options.output);
+  const outputDir = path8.resolve(options.output);
   const writtenFiles = await writeLwcBundle(outputDir, result.bundle, options.dryRun);
   if (result.notes.length > 0) {
     await writeConversionNotes(outputDir, result.bundle.name, result.notes, options.dryRun);
   }
   logger.divider();
-  logger.success("Conversion complete!");
+  const totalFiles = writtenFiles.length + 1;
+  logger.successToast(
+    "Conversion Complete",
+    [
+      `${vfPage.name} \u2192 ${result.bundle.name}`,
+      `${totalFiles} files created`
+    ],
+    path8.join(outputDir, result.bundle.name)
+  );
   logger.summaryBox("Conversion Summary", [
     { label: "Page", value: `${vfPage.name} \u2192 ${result.bundle.name}`, type: "success" },
-    { label: "Files created", value: `${writtenFiles.length + 1}`, type: "info" },
+    { label: "Files created", value: `${totalFiles}`, type: "info" },
     { label: "Warnings", value: `${result.warnings.length}`, type: result.warnings.length > 0 ? "warn" : "success" },
-    { label: "Output", value: path7.join(outputDir, result.bundle.name), type: "info" }
+    { label: "Output", value: path8.join(outputDir, result.bundle.name), type: "info" }
   ]);
   if (result.warnings.length > 0) {
     if (options.verbose) {
@@ -8853,6 +8950,7 @@ var init_vf = __esm({
     init_full_conversion();
     init_path_resolver();
     init_preview_generator();
+    init_project_detector();
   }
 });
 
@@ -9276,8 +9374,8 @@ var init_vf_grader = __esm({
 });
 
 // src/grading/grader.ts
-import fs6 from "fs-extra";
-import * as path9 from "path";
+import fs7 from "fs-extra";
+import * as path10 from "path";
 var Grader;
 var init_grader = __esm({
   "src/grading/grader.ts"() {
@@ -9298,13 +9396,13 @@ var init_grader = __esm({
        * Read sfdx-project.json and return package directories
        */
       async getPackageDirectories(rootPath) {
-        const sfdxProjectPath = path9.join(rootPath, "sfdx-project.json");
-        if (await fs6.pathExists(sfdxProjectPath)) {
+        const sfdxProjectPath = path10.join(rootPath, "sfdx-project.json");
+        if (await fs7.pathExists(sfdxProjectPath)) {
           try {
-            const projectConfig = await fs6.readJson(sfdxProjectPath);
+            const projectConfig = await fs7.readJson(sfdxProjectPath);
             if (projectConfig.packageDirectories && Array.isArray(projectConfig.packageDirectories)) {
               return projectConfig.packageDirectories.map(
-                (pkg) => path9.join(rootPath, pkg.path)
+                (pkg) => path10.join(rootPath, pkg.path)
               );
             }
           } catch (error) {
@@ -9323,10 +9421,10 @@ var init_grader = __esm({
         const searchDir = async (dirPath, depth = 0) => {
           if (depth > 5) return;
           try {
-            const entries = await fs6.readdir(dirPath, { withFileTypes: true });
+            const entries = await fs7.readdir(dirPath, { withFileTypes: true });
             for (const entry of entries) {
               if (entry.isDirectory()) {
-                const fullPath = path9.join(dirPath, entry.name);
+                const fullPath = path10.join(dirPath, entry.name);
                 if (entry.name === "pages") {
                   pagesDirectories.push(fullPath);
                 } else if (entry.name === "components") {
@@ -9371,7 +9469,7 @@ var init_grader = __esm({
       async gradeSingle(filePath, type) {
         const resolvedType = type === "both" ? this.detectType(filePath) : type;
         if (resolvedType === "aura") {
-          const bundlePath = filePath.endsWith(".cmp") ? path9.dirname(filePath) : filePath;
+          const bundlePath = filePath.endsWith(".cmp") ? path10.dirname(filePath) : filePath;
           return this.auraGrader.grade(bundlePath);
         } else if (resolvedType === "vf") {
           return this.vfGrader.grade(filePath);
@@ -9403,8 +9501,8 @@ var init_grader = __esm({
         }
         if (type === "aura" || type === "both") {
           const auraFallbacks = [
-            path9.join(cwd, "force-app/main/default/aura"),
-            path9.join(cwd, "src/aura")
+            path10.join(cwd, "force-app/main/default/aura"),
+            path10.join(cwd, "src/aura")
           ];
           for (const fallback of auraFallbacks) {
             if (!paths.includes(fallback)) {
@@ -9414,10 +9512,10 @@ var init_grader = __esm({
         }
         if (type === "vf" || type === "both") {
           const vfFallbacks = [
-            path9.join(cwd, "force-app/main/default/pages"),
-            path9.join(cwd, "src/pages"),
-            path9.join(cwd, "force-app/main/default/components"),
-            path9.join(cwd, "src/components")
+            path10.join(cwd, "force-app/main/default/pages"),
+            path10.join(cwd, "src/pages"),
+            path10.join(cwd, "force-app/main/default/components"),
+            path10.join(cwd, "src/components")
           ];
           for (const fallback of vfFallbacks) {
             if (!paths.includes(fallback)) {
@@ -9429,14 +9527,14 @@ var init_grader = __esm({
       }
       async scanDirectory(dir, type) {
         const results = [];
-        if (!await fs6.pathExists(dir)) return results;
+        if (!await fs7.pathExists(dir)) return results;
         async function walk(currentDir) {
-          const entries = await fs6.readdir(currentDir, { withFileTypes: true });
+          const entries = await fs7.readdir(currentDir, { withFileTypes: true });
           for (const entry of entries) {
-            const fullPath = path9.join(currentDir, entry.name);
+            const fullPath = path10.join(currentDir, entry.name);
             if (entry.isDirectory()) {
               if (type !== "vf") {
-                const children = await fs6.readdir(fullPath);
+                const children = await fs7.readdir(fullPath);
                 if (children.some((f) => f.endsWith(".cmp"))) {
                   results.push(fullPath);
                   continue;
@@ -9575,7 +9673,7 @@ var require_picocolors = __commonJS({
 });
 
 // src/utils/vf-controller-resolver.ts
-import fs11 from "fs-extra";
+import fs12 from "fs-extra";
 function extractControllerNames(markup) {
   const controllers = [];
   const seen = /* @__PURE__ */ new Set();
@@ -9671,8 +9769,8 @@ __export(interactive_exports, {
   runInteractiveTui: () => runInteractiveTui
 });
 import * as p from "@clack/prompts";
-import * as path13 from "path";
-import fs12 from "fs-extra";
+import * as path14 from "path";
+import fs13 from "fs-extra";
 function showBreadcrumbs(currentStep, conversionType) {
   const breadcrumb = STEPS.map((step, i) => {
     if (step === "Controllers" && conversionType === "aura") {
@@ -9699,16 +9797,16 @@ async function findAuraComponents() {
   const components3 = [];
   const cwd = process.cwd();
   for (const searchPath of searchPaths) {
-    const fullPath = path13.join(cwd, searchPath);
-    if (await fs12.pathExists(fullPath)) {
+    const fullPath = path14.join(cwd, searchPath);
+    if (await fs13.pathExists(fullPath)) {
       try {
-        const entries = await fs12.readdir(fullPath, { withFileTypes: true });
+        const entries = await fs13.readdir(fullPath, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isDirectory()) {
-            const cmpFile = path13.join(fullPath, entry.name, `${entry.name}.cmp`);
-            if (await fs12.pathExists(cmpFile)) {
+            const cmpFile = path14.join(fullPath, entry.name, `${entry.name}.cmp`);
+            if (await fs13.pathExists(cmpFile)) {
               components3.push({
-                value: path13.join(searchPath, entry.name),
+                value: path14.join(searchPath, entry.name),
                 label: `\u26A1 ${entry.name}`,
                 hint: searchPath
               });
@@ -9730,14 +9828,14 @@ async function findVfPages() {
   const pages = [];
   const cwd = process.cwd();
   for (const searchPath of searchPaths) {
-    const fullPath = path13.join(cwd, searchPath);
-    if (await fs12.pathExists(fullPath)) {
+    const fullPath = path14.join(cwd, searchPath);
+    if (await fs13.pathExists(fullPath)) {
       try {
-        const entries = await fs12.readdir(fullPath, { withFileTypes: true });
+        const entries = await fs13.readdir(fullPath, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isFile() && entry.name.endsWith(".page")) {
             pages.push({
-              value: path13.join(searchPath, entry.name),
+              value: path14.join(searchPath, entry.name),
               label: `\u{1F4C4} ${entry.name.replace(".page", "")}`,
               hint: searchPath
             });
@@ -9758,14 +9856,14 @@ async function findApexControllers() {
   const controllers = [];
   const cwd = process.cwd();
   for (const searchPath of searchPaths) {
-    const fullPath = path13.join(cwd, searchPath);
-    if (await fs12.pathExists(fullPath)) {
+    const fullPath = path14.join(cwd, searchPath);
+    if (await fs13.pathExists(fullPath)) {
       try {
-        const entries = await fs12.readdir(fullPath, { withFileTypes: true });
+        const entries = await fs13.readdir(fullPath, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isFile() && entry.name.endsWith(".cls")) {
             controllers.push({
-              value: path13.join(searchPath, entry.name),
+              value: path14.join(searchPath, entry.name),
               label: `\u{1F4CB} ${entry.name.replace(".cls", "")}`
             });
           }
@@ -9991,11 +10089,11 @@ async function runInteractiveTui() {
     }
     while (currentStep === 2 && conversionType === "vf" && componentPath && action !== "grade") {
       showBreadcrumbs(currentStep, conversionType);
-      const resolvedPagePath = path13.resolve(componentPath);
-      if (await fs12.pathExists(resolvedPagePath)) {
+      const resolvedPagePath = path14.resolve(componentPath);
+      if (await fs13.pathExists(resolvedPagePath)) {
         const s = p.spinner();
         s.start("Analyzing page for controller references...");
-        const pageContent = await fs12.readFile(resolvedPagePath, "utf-8");
+        const pageContent = await fs13.readFile(resolvedPagePath, "utf-8");
         const result = await findVfControllers(pageContent);
         detectedControllers = result.controllers;
         s.stop("Analysis complete");
@@ -10045,7 +10143,7 @@ async function runInteractiveTui() {
           if (addMore) {
             const allControllers = await findApexControllers();
             const availableControllers = allControllers.filter(
-              (c) => !controllerPaths.includes(path13.resolve(c.value))
+              (c) => !controllerPaths.includes(path14.resolve(c.value))
             );
             if (availableControllers.length > 0) {
               const additional = await p.multiselect({
@@ -10054,7 +10152,7 @@ async function runInteractiveTui() {
                 required: false
               });
               if (!isCancel2(additional)) {
-                controllerPaths.push(...additional.map((c) => path13.resolve(c)));
+                controllerPaths.push(...additional.map((c) => path14.resolve(c)));
               }
             }
           }
@@ -10081,7 +10179,7 @@ async function runInteractiveTui() {
                 continue wizardLoop;
               }
               controllerPath = selected;
-              controllerPaths = [path13.resolve(controllerPath)];
+              controllerPaths = [path14.resolve(controllerPath)];
             }
           }
         }
@@ -10188,7 +10286,7 @@ async function runInteractiveTui() {
     if (controllerPaths.length > 0) {
       summaryLines.push(`${import_picocolors.default.dim("Controllers:")}  ${controllerPaths.length} selected`);
       controllerPaths.forEach((cp) => {
-        summaryLines.push(`               ${import_picocolors.default.dim("\u2022")} ${path13.basename(cp)}`);
+        summaryLines.push(`               ${import_picocolors.default.dim("\u2022")} ${path14.basename(cp)}`);
       });
     }
     summaryLines.push(`${import_picocolors.default.dim("Mode:")}         ${conversionMode === "full" ? "\u26A1 Full" : "\u{1F4DD} Scaffolding"}`);
@@ -10256,13 +10354,13 @@ var init_types = __esm({
 });
 
 // src/tui/store/persistence.ts
-import fs13 from "fs-extra";
-import path14 from "path";
+import fs14 from "fs-extra";
+import path15 from "path";
 import os4 from "os";
 async function savePreferences(prefs) {
   try {
-    await fs13.ensureDir(CONFIG_DIR);
-    await fs13.writeJson(PREFS_PATH, prefs, { spaces: 2 });
+    await fs14.ensureDir(CONFIG_DIR);
+    await fs14.writeJson(PREFS_PATH, prefs, { spaces: 2 });
   } catch (error) {
     console.error("Error saving preferences:", error);
     throw error;
@@ -10270,9 +10368,9 @@ async function savePreferences(prefs) {
 }
 function loadPreferencesSync() {
   try {
-    fs13.ensureDirSync(CONFIG_DIR);
-    if (fs13.pathExistsSync(PREFS_PATH)) {
-      const data = fs13.readJsonSync(PREFS_PATH);
+    fs14.ensureDirSync(CONFIG_DIR);
+    if (fs14.pathExistsSync(PREFS_PATH)) {
+      const data = fs14.readJsonSync(PREFS_PATH);
       return { ...DEFAULT_PREFERENCES, ...data };
     }
   } catch (error) {
@@ -10285,8 +10383,8 @@ var init_persistence = __esm({
     "use strict";
     init_esm_shims();
     init_types();
-    CONFIG_DIR = path14.join(os4.homedir(), ".lwc-convert");
-    PREFS_PATH = path14.join(CONFIG_DIR, "preferences.json");
+    CONFIG_DIR = path15.join(os4.homedir(), ".lwc-convert");
+    PREFS_PATH = path15.join(CONFIG_DIR, "preferences.json");
   }
 });
 
@@ -10433,8 +10531,8 @@ var init_store = __esm({
         await savePreferences(newPrefs);
       },
       // Project actions
-      setProjectPath: (path16) => {
-        set({ projectPath: path16 });
+      setProjectPath: (path17) => {
+        set({ projectPath: path17 });
       },
       setComponents: (aura, vf) => {
         set({ auraComponents: aura, vfComponents: vf });
@@ -11188,8 +11286,8 @@ var init_feedback = __esm({
 });
 
 // src/tui/utils/discovery.ts
-import fs14 from "fs-extra";
-import path15 from "path";
+import fs15 from "fs-extra";
+import path16 from "path";
 async function discoverComponents(projectPath) {
   const auraComponents = [];
   const vfComponents = [];
@@ -11202,8 +11300,8 @@ async function discoverComponents(projectPath) {
     "pages"
   ];
   for (const searchPath of searchPaths) {
-    const fullPath = path15.join(projectPath, searchPath);
-    if (await fs14.pathExists(fullPath)) {
+    const fullPath = path16.join(projectPath, searchPath);
+    if (await fs15.pathExists(fullPath)) {
       if (searchPath.includes("aura")) {
         const components3 = await discoverAuraComponents(fullPath);
         auraComponents.push(...components3);
@@ -11219,8 +11317,8 @@ async function discoverComponents(projectPath) {
     "components"
   ];
   for (const searchPath of vfComponentPaths) {
-    const fullPath = path15.join(projectPath, searchPath);
-    if (await fs14.pathExists(fullPath)) {
+    const fullPath = path16.join(projectPath, searchPath);
+    if (await fs15.pathExists(fullPath)) {
       const components3 = await discoverVfComponents(fullPath);
       vfComponents.push(...components3);
     }
@@ -11240,11 +11338,11 @@ async function discoverComponents(projectPath) {
 async function discoverAuraComponents(auraPath) {
   const components3 = [];
   try {
-    const entries = await fs14.readdir(auraPath, { withFileTypes: true });
+    const entries = await fs15.readdir(auraPath, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const componentPath = path15.join(auraPath, entry.name);
-        const files = await fs14.readdir(componentPath);
+        const componentPath = path16.join(auraPath, entry.name);
+        const files = await fs15.readdir(componentPath);
         const cmpFile = files.find((f) => f.endsWith(".cmp"));
         if (cmpFile) {
           components3.push({
@@ -11268,14 +11366,14 @@ async function discoverAuraComponents(auraPath) {
 async function discoverVfPages(pagesPath) {
   const pages = [];
   try {
-    const entries = await fs14.readdir(pagesPath, { withFileTypes: true });
+    const entries = await fs15.readdir(pagesPath, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".page")) {
         const name = entry.name.replace(".page", "");
-        const pagePath = path15.join(pagesPath, entry.name);
+        const pagePath = path16.join(pagesPath, entry.name);
         const relatedFiles = [entry.name];
         const metaFile = `${entry.name}-meta.xml`;
-        if (await fs14.pathExists(path15.join(pagesPath, metaFile))) {
+        if (await fs15.pathExists(path16.join(pagesPath, metaFile))) {
           relatedFiles.push(metaFile);
         }
         pages.push({
@@ -11297,11 +11395,11 @@ async function discoverVfPages(pagesPath) {
 async function discoverVfComponents(componentsPath) {
   const components3 = [];
   try {
-    const entries = await fs14.readdir(componentsPath, { withFileTypes: true });
+    const entries = await fs15.readdir(componentsPath, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".component")) {
         const name = entry.name.replace(".component", "");
-        const componentPath = path15.join(componentsPath, entry.name);
+        const componentPath = path16.join(componentsPath, entry.name);
         components3.push({
           id: `vf-component-${name}`,
           name,
@@ -13094,7 +13192,7 @@ function ConversionWizard() {
                 setSelectedComponentIndex(0);
                 setComponentListScrollOffset(0);
               },
-              onSourcePathChange: (path16) => updateWizardState({ sourcePath: path16 }),
+              onSourcePathChange: (path17) => updateWizardState({ sourcePath: path17 }),
               onComponentSelect: (component) => {
                 updateWizardState({ sourcePath: component.path });
               },
@@ -13406,7 +13504,7 @@ var init_Modal = __esm({
 // src/tui/screens/ExportModal.tsx
 import { useState as useState8 } from "react";
 import { Box as Box18, Text as Text21 } from "ink";
-import fs15 from "fs-extra";
+import fs16 from "fs-extra";
 import { Fragment, jsx as jsx19, jsxs as jsxs19 } from "react/jsx-runtime";
 function ExportModal() {
   const preferences = useStore((state) => state.preferences);
@@ -13447,7 +13545,7 @@ function ExportModal() {
         default:
           content = JSON.stringify(data, null, 2);
       }
-      await fs15.writeFile(options.outputPath, content);
+      await fs16.writeFile(options.outputPath, content);
       setExportSuccess(true);
       setTimeout(() => {
         closeModal();
@@ -13559,7 +13657,7 @@ function ExportModal() {
       {
         label: "Output Path",
         value: options.outputPath,
-        onChange: (path16) => setOptions((o) => ({ ...o, outputPath: path16 })),
+        onChange: (path17) => setOptions((o) => ({ ...o, outputPath: path17 })),
         focus: focusedField === 4
       }
     ) }),
@@ -13887,10 +13985,10 @@ import { Command } from "commander";
 // src/utils/update-checker.ts
 init_esm_shims();
 init_options();
-import fs5 from "fs-extra";
-import path8 from "path";
+import fs6 from "fs-extra";
+import path9 from "path";
 import os3 from "os";
-var CACHE_FILE = path8.join(os3.tmpdir(), "lwc-convert-update-check.json");
+var CACHE_FILE = path9.join(os3.tmpdir(), "lwc-convert-update-check.json");
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var FETCH_TIMEOUT_MS = 3e3;
 async function fetchLatestVersion() {
@@ -13925,8 +14023,8 @@ function isNewerVersion(latest, current) {
 }
 async function readCache() {
   try {
-    if (await fs5.pathExists(CACHE_FILE)) {
-      return await fs5.readJson(CACHE_FILE);
+    if (await fs6.pathExists(CACHE_FILE)) {
+      return await fs6.readJson(CACHE_FILE);
     }
   } catch {
   }
@@ -13934,7 +14032,7 @@ async function readCache() {
 }
 async function writeCache(cache) {
   try {
-    await fs5.writeJson(CACHE_FILE, cache);
+    await fs6.writeJson(CACHE_FILE, cache);
   } catch {
   }
 }
@@ -13974,7 +14072,7 @@ init_esm_shims();
 init_logger();
 init_grader();
 init_path_resolver();
-import fs7 from "fs-extra";
+import fs8 from "fs-extra";
 
 // src/cli/tui/grade-tui.ts
 init_esm_shims();
@@ -14272,7 +14370,7 @@ async function launchGradeTui(components3, summary) {
   process.stdin.setRawMode(true);
   hideCursor();
   render(state);
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const handleKeypress = (str, key) => {
       if (!key) return;
       if (state.isSearching) {
@@ -14295,7 +14393,7 @@ async function launchGradeTui(components3, summary) {
         showCursor();
         clearScreen();
         process.stdin.setRawMode(false);
-        resolve7();
+        resolve8();
         return;
       }
       if (state.viewMode === "detail") {
@@ -14361,15 +14459,34 @@ function shouldUseInteractive() {
 }
 
 // src/cli/commands/grade.ts
+function getGradeEmoji(grade2) {
+  switch (grade2) {
+    case "A":
+      return "\u{1F7E2}";
+    case "B":
+      return "\u{1F7E1}";
+    case "C":
+      return "\u{1F7E0}";
+    case "D":
+      return "\u{1F534}";
+    case "F":
+      return "\u26D4";
+    default:
+      return "\u26AA";
+  }
+}
+function getComplexityIcon(complexity) {
+  return complexity.includes("Complex") || complexity === "Moderate" ? "\u26A0" : "\u2713";
+}
 async function grade(target, options) {
   const grader = new Grader();
   let scope = "project";
   let targetPath = target;
   if (target) {
-    if (await fs7.pathExists(target)) {
-      const stat = await fs7.stat(target);
+    if (await fs8.pathExists(target)) {
+      const stat = await fs8.stat(target);
       if (stat.isDirectory()) {
-        const files = await fs7.readdir(target);
+        const files = await fs8.readdir(target);
         if (files.some((f) => f.endsWith(".cmp"))) {
           scope = "component";
         } else {
@@ -14428,7 +14545,7 @@ async function grade(target, options) {
     if (options.format === "json") {
       const output = { summary, components: filteredResults };
       if (options.output) {
-        await fs7.writeJson(options.output, output, { spaces: 2 });
+        await fs8.writeJson(options.output, output, { spaces: 2 });
         logger.success(`Results written to ${options.output}`);
       } else {
         console.log(JSON.stringify(output, null, 2));
@@ -14436,7 +14553,7 @@ async function grade(target, options) {
     } else if (options.format === "csv") {
       const csvContent = generateCsvReport(filteredResults, summary);
       if (options.output) {
-        await fs7.writeFile(options.output, csvContent);
+        await fs8.writeFile(options.output, csvContent);
         logger.success(`CSV report written to ${options.output}`);
       } else {
         console.log(csvContent);
@@ -14493,11 +14610,14 @@ function filterResults(results, filter) {
   return results;
 }
 function printConsoleReport(results, summary, detailed) {
-  console.log("Component".padEnd(30) + "Type".padEnd(10) + "Score".padEnd(10) + "Grade".padEnd(10) + "Complexity");
-  console.log("-".repeat(80));
+  console.log("");
+  console.log("Components:");
   results.forEach((r) => {
+    const emoji = getGradeEmoji(r.letterGrade);
+    const icon = getComplexityIcon(r.complexity);
+    const effort = `${r.conversionEffort.manualHours.estimate}h`;
     console.log(
-      r.componentName.padEnd(30) + r.componentType.padEnd(10) + r.overallScore.toString().padEnd(10) + r.letterGrade.padEnd(10) + r.complexity
+      `  ${emoji} ${r.letterGrade.padEnd(2)}  ${r.componentName.padEnd(24)}Score: ${r.overallScore.toString().padStart(2)}   Effort: ${effort.padStart(4)}   ${icon} ${r.complexity}`
     );
   });
   logger.blank();
@@ -14571,8 +14691,8 @@ function generateCsvReport(results, summary) {
 // src/cli/commands/deps.ts
 init_esm_shims();
 init_logger();
-import fs10 from "fs-extra";
-import * as path12 from "path";
+import fs11 from "fs-extra";
+import * as path13 from "path";
 
 // src/dependency-graph/analyzer.ts
 init_esm_shims();
@@ -14581,8 +14701,8 @@ init_logger();
 // src/dependency-graph/aura-dependency-analyzer.ts
 init_esm_shims();
 init_logger();
-import fs8 from "fs-extra";
-import * as path10 from "path";
+import fs9 from "fs-extra";
+import * as path11 from "path";
 import * as htmlparser23 from "htmlparser2";
 import { DomHandler as DomHandler3 } from "domhandler";
 function extractMarkupDependencies(markup, includeBaseComponents) {
@@ -14755,13 +14875,13 @@ function extractJsDependencies(jsContent) {
 }
 async function analyzeAuraComponent(bundlePath, includeBaseComponents = false) {
   try {
-    const stat = await fs8.stat(bundlePath);
+    const stat = await fs9.stat(bundlePath);
     if (!stat.isDirectory()) {
       logger.debug(`Not a directory: ${bundlePath}`);
       return null;
     }
-    const componentName = path10.basename(bundlePath);
-    const files = await fs8.readdir(bundlePath);
+    const componentName = path11.basename(bundlePath);
+    const files = await fs9.readdir(bundlePath);
     const cmpFile = files.find((f) => f.endsWith(".cmp"));
     if (!cmpFile) {
       logger.debug(`No .cmp file found in ${bundlePath}`);
@@ -14770,18 +14890,18 @@ async function analyzeAuraComponent(bundlePath, includeBaseComponents = false) {
     const context = {
       markup: ""
     };
-    context.markup = await fs8.readFile(path10.join(bundlePath, cmpFile), "utf-8");
+    context.markup = await fs9.readFile(path11.join(bundlePath, cmpFile), "utf-8");
     const controllerFile = files.find((f) => f.endsWith("Controller.js"));
     if (controllerFile) {
-      context.controllerJs = await fs8.readFile(
-        path10.join(bundlePath, controllerFile),
+      context.controllerJs = await fs9.readFile(
+        path11.join(bundlePath, controllerFile),
         "utf-8"
       );
     }
     const helperFile = files.find((f) => f.endsWith("Helper.js"));
     if (helperFile) {
-      context.helperJs = await fs8.readFile(
-        path10.join(bundlePath, helperFile),
+      context.helperJs = await fs9.readFile(
+        path11.join(bundlePath, helperFile),
         "utf-8"
       );
     }
@@ -14806,13 +14926,13 @@ async function analyzeAuraComponent(bundlePath, includeBaseComponents = false) {
   }
 }
 async function getPackageDirectories(rootPath) {
-  const sfdxProjectPath = path10.join(rootPath, "sfdx-project.json");
-  if (await fs8.pathExists(sfdxProjectPath)) {
+  const sfdxProjectPath = path11.join(rootPath, "sfdx-project.json");
+  if (await fs9.pathExists(sfdxProjectPath)) {
     try {
-      const projectConfig = await fs8.readJson(sfdxProjectPath);
+      const projectConfig = await fs9.readJson(sfdxProjectPath);
       if (projectConfig.packageDirectories && Array.isArray(projectConfig.packageDirectories)) {
         return projectConfig.packageDirectories.map(
-          (pkg) => path10.join(rootPath, pkg.path)
+          (pkg) => path11.join(rootPath, pkg.path)
         );
       }
     } catch (error) {
@@ -14826,10 +14946,10 @@ async function findAuraDirectories(basePath) {
   async function searchDir(dirPath, depth = 0) {
     if (depth > 5) return;
     try {
-      const entries = await fs8.readdir(dirPath, { withFileTypes: true });
+      const entries = await fs9.readdir(dirPath, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const fullPath = path10.join(dirPath, entry.name);
+          const fullPath = path11.join(dirPath, entry.name);
           if (entry.name === "aura") {
             auraDirectories.push(fullPath);
           } else if (!entry.name.startsWith(".") && entry.name !== "node_modules") {
@@ -14855,19 +14975,19 @@ async function scanAuraComponents(rootPath, includeBaseComponents = false) {
     logger.debug(`Found aura directories from sfdx-project.json: ${searchPaths.join(", ")}`);
   }
   const fallbackPaths = [
-    path10.join(rootPath, "force-app/main/default/aura"),
-    path10.join(rootPath, "src/aura"),
-    path10.join(rootPath, "aura")
+    path11.join(rootPath, "force-app/main/default/aura"),
+    path11.join(rootPath, "src/aura"),
+    path11.join(rootPath, "aura")
   ];
   for (const fallback of fallbackPaths) {
     if (!searchPaths.includes(fallback)) {
       searchPaths.push(fallback);
     }
   }
-  if (await fs8.pathExists(rootPath)) {
-    const stat = await fs8.stat(rootPath);
+  if (await fs9.pathExists(rootPath)) {
+    const stat = await fs9.stat(rootPath);
     if (stat.isDirectory()) {
-      const files = await fs8.readdir(rootPath);
+      const files = await fs9.readdir(rootPath);
       if (files.some((f) => f.endsWith(".cmp"))) {
         searchPaths.unshift(rootPath);
       }
@@ -14875,10 +14995,10 @@ async function scanAuraComponents(rootPath, includeBaseComponents = false) {
   }
   logger.debug(`Searching for Aura components in: ${searchPaths.join(", ")}`);
   for (const searchPath of searchPaths) {
-    if (await fs8.pathExists(searchPath)) {
-      const stat = await fs8.stat(searchPath);
+    if (await fs9.pathExists(searchPath)) {
+      const stat = await fs9.stat(searchPath);
       if (stat.isDirectory()) {
-        const files = await fs8.readdir(searchPath);
+        const files = await fs9.readdir(searchPath);
         if (files.some((f) => f.endsWith(".cmp"))) {
           const result = await analyzeAuraComponent(searchPath, includeBaseComponents);
           if (result) {
@@ -14886,8 +15006,8 @@ async function scanAuraComponents(rootPath, includeBaseComponents = false) {
           }
         } else {
           for (const item of files) {
-            const itemPath = path10.join(searchPath, item);
-            const itemStat = await fs8.stat(itemPath);
+            const itemPath = path11.join(searchPath, item);
+            const itemStat = await fs9.stat(itemPath);
             if (itemStat.isDirectory()) {
               const result = await analyzeAuraComponent(itemPath, includeBaseComponents);
               if (result) {
@@ -14910,8 +15030,8 @@ async function scanAuraComponents(rootPath, includeBaseComponents = false) {
 // src/dependency-graph/vf-dependency-analyzer.ts
 init_esm_shims();
 init_logger();
-import fs9 from "fs-extra";
-import * as path11 from "path";
+import fs10 from "fs-extra";
+import * as path12 from "path";
 import * as htmlparser24 from "htmlparser2";
 import { DomHandler as DomHandler4 } from "domhandler";
 function extractVfDependencies(markup) {
@@ -15093,25 +15213,25 @@ async function analyzeVfPage(pagePath) {
   try {
     let actualPath = pagePath;
     if (!pagePath.endsWith(".page")) {
-      if (await fs9.pathExists(pagePath)) {
-        const stat = await fs9.stat(pagePath);
+      if (await fs10.pathExists(pagePath)) {
+        const stat = await fs10.stat(pagePath);
         if (stat.isDirectory()) {
-          const files = await fs9.readdir(pagePath);
+          const files = await fs10.readdir(pagePath);
           const pageFile = files.find((f) => f.endsWith(".page"));
           if (pageFile) {
-            actualPath = path11.join(pagePath, pageFile);
+            actualPath = path12.join(pagePath, pageFile);
           } else {
             return null;
           }
         }
       }
     }
-    if (!await fs9.pathExists(actualPath)) {
+    if (!await fs10.pathExists(actualPath)) {
       logger.debug(`VF page not found: ${actualPath}`);
       return null;
     }
-    const markup = await fs9.readFile(actualPath, "utf-8");
-    const pageName = path11.basename(actualPath, ".page");
+    const markup = await fs10.readFile(actualPath, "utf-8");
+    const pageName = path12.basename(actualPath, ".page");
     const dependencies = extractVfDependencies(markup);
     return {
       id: `vf:${pageName}`,
@@ -15129,25 +15249,25 @@ async function analyzeVfComponent(componentPath) {
   try {
     let actualPath = componentPath;
     if (!componentPath.endsWith(".component")) {
-      if (await fs9.pathExists(componentPath)) {
-        const stat = await fs9.stat(componentPath);
+      if (await fs10.pathExists(componentPath)) {
+        const stat = await fs10.stat(componentPath);
         if (stat.isDirectory()) {
-          const files = await fs9.readdir(componentPath);
+          const files = await fs10.readdir(componentPath);
           const componentFile = files.find((f) => f.endsWith(".component"));
           if (componentFile) {
-            actualPath = path11.join(componentPath, componentFile);
+            actualPath = path12.join(componentPath, componentFile);
           } else {
             return null;
           }
         }
       }
     }
-    if (!await fs9.pathExists(actualPath)) {
+    if (!await fs10.pathExists(actualPath)) {
       logger.debug(`VF component not found: ${actualPath}`);
       return null;
     }
-    const markup = await fs9.readFile(actualPath, "utf-8");
-    const componentName = path11.basename(actualPath, ".component");
+    const markup = await fs10.readFile(actualPath, "utf-8");
+    const componentName = path12.basename(actualPath, ".component");
     const dependencies = extractVfDependencies(markup);
     return {
       id: `vf:${componentName}`,
@@ -15162,13 +15282,13 @@ async function analyzeVfComponent(componentPath) {
   }
 }
 async function getPackageDirectories2(rootPath) {
-  const sfdxProjectPath = path11.join(rootPath, "sfdx-project.json");
-  if (await fs9.pathExists(sfdxProjectPath)) {
+  const sfdxProjectPath = path12.join(rootPath, "sfdx-project.json");
+  if (await fs10.pathExists(sfdxProjectPath)) {
     try {
-      const projectConfig = await fs9.readJson(sfdxProjectPath);
+      const projectConfig = await fs10.readJson(sfdxProjectPath);
       if (projectConfig.packageDirectories && Array.isArray(projectConfig.packageDirectories)) {
         return projectConfig.packageDirectories.map(
-          (pkg) => path11.join(rootPath, pkg.path)
+          (pkg) => path12.join(rootPath, pkg.path)
         );
       }
     } catch (error) {
@@ -15183,10 +15303,10 @@ async function findVfDirectories(basePath) {
   async function searchDir(dirPath, depth = 0) {
     if (depth > 5) return;
     try {
-      const entries = await fs9.readdir(dirPath, { withFileTypes: true });
+      const entries = await fs10.readdir(dirPath, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const fullPath = path11.join(dirPath, entry.name);
+          const fullPath = path12.join(dirPath, entry.name);
           if (entry.name === "pages") {
             pagesDirectories.push(fullPath);
           } else if (entry.name === "components") {
@@ -15217,9 +15337,9 @@ async function scanVfPages(rootPath) {
     logger.debug(`Found components directories from sfdx-project.json: ${componentSearchPaths.join(", ")}`);
   }
   const fallbackPagePaths = [
-    path11.join(rootPath, "force-app/main/default/pages"),
-    path11.join(rootPath, "src/pages"),
-    path11.join(rootPath, "pages")
+    path12.join(rootPath, "force-app/main/default/pages"),
+    path12.join(rootPath, "src/pages"),
+    path12.join(rootPath, "pages")
   ];
   for (const fallback of fallbackPagePaths) {
     if (!pageSearchPaths.includes(fallback)) {
@@ -15227,9 +15347,9 @@ async function scanVfPages(rootPath) {
     }
   }
   const fallbackComponentPaths = [
-    path11.join(rootPath, "force-app/main/default/components"),
-    path11.join(rootPath, "src/components"),
-    path11.join(rootPath, "components")
+    path12.join(rootPath, "force-app/main/default/components"),
+    path12.join(rootPath, "src/components"),
+    path12.join(rootPath, "components")
   ];
   for (const fallback of fallbackComponentPaths) {
     if (!componentSearchPaths.includes(fallback)) {
@@ -15240,10 +15360,10 @@ async function scanVfPages(rootPath) {
     pageSearchPaths.unshift(rootPath);
   } else if (rootPath.endsWith(".component")) {
     componentSearchPaths.unshift(rootPath);
-  } else if (await fs9.pathExists(rootPath)) {
-    const stat = await fs9.stat(rootPath);
+  } else if (await fs10.pathExists(rootPath)) {
+    const stat = await fs10.stat(rootPath);
     if (stat.isDirectory()) {
-      const files = await fs9.readdir(rootPath);
+      const files = await fs10.readdir(rootPath);
       if (files.some((f) => f.endsWith(".page"))) {
         pageSearchPaths.unshift(rootPath);
       }
@@ -15255,18 +15375,18 @@ async function scanVfPages(rootPath) {
   logger.debug(`Searching for VF pages in: ${pageSearchPaths.join(", ")}`);
   logger.debug(`Searching for VF components in: ${componentSearchPaths.join(", ")}`);
   for (const searchPath of pageSearchPaths) {
-    if (await fs9.pathExists(searchPath)) {
-      const stat = await fs9.stat(searchPath);
+    if (await fs10.pathExists(searchPath)) {
+      const stat = await fs10.stat(searchPath);
       if (stat.isFile() && searchPath.endsWith(".page")) {
         const result = await analyzeVfPage(searchPath);
         if (result) {
           results.push(result);
         }
       } else if (stat.isDirectory()) {
-        const files = await fs9.readdir(searchPath);
+        const files = await fs10.readdir(searchPath);
         for (const file of files) {
           if (file.endsWith(".page")) {
-            const result = await analyzeVfPage(path11.join(searchPath, file));
+            const result = await analyzeVfPage(path12.join(searchPath, file));
             if (result) {
               results.push(result);
             }
@@ -15276,18 +15396,18 @@ async function scanVfPages(rootPath) {
     }
   }
   for (const searchPath of componentSearchPaths) {
-    if (await fs9.pathExists(searchPath)) {
-      const stat = await fs9.stat(searchPath);
+    if (await fs10.pathExists(searchPath)) {
+      const stat = await fs10.stat(searchPath);
       if (stat.isFile() && searchPath.endsWith(".component")) {
         const result = await analyzeVfComponent(searchPath);
         if (result) {
           results.push(result);
         }
       } else if (stat.isDirectory()) {
-        const files = await fs9.readdir(searchPath);
+        const files = await fs10.readdir(searchPath);
         for (const file of files) {
           if (file.endsWith(".component")) {
-            const result = await analyzeVfComponent(path11.join(searchPath, file));
+            const result = await analyzeVfComponent(path12.join(searchPath, file));
             if (result) {
               results.push(result);
             }
@@ -16294,7 +16414,7 @@ function formatSimpleMermaidOutput(graph, maxNodes = 30) {
 // src/cli/commands/deps.ts
 async function analyzeDeps(target, options) {
   logger.setVerbose(options.verbose);
-  const targetPath = target ? path12.resolve(target) : process.cwd();
+  const targetPath = target ? path13.resolve(target) : process.cwd();
   logger.banner();
   logger.header("Dependency Graph Analysis");
   logger.info(`Analyzing: ${targetPath}`);
@@ -16370,10 +16490,10 @@ async function analyzeDeps(target, options) {
   }
 }
 async function writeOutput(filePath, content) {
-  const outputPath = path12.resolve(filePath);
-  const outputDir = path12.dirname(outputPath);
-  await fs10.ensureDir(outputDir);
-  await fs10.writeFile(outputPath, content, "utf-8");
+  const outputPath = path13.resolve(filePath);
+  const outputDir = path13.dirname(outputPath);
+  await fs11.ensureDir(outputDir);
+  await fs11.writeFile(outputPath, content, "utf-8");
 }
 
 // src/index.ts