slicejs-cli 3.4.0 → 3.4.1

package/commands/listComponents/listComponents.js

@@ -1,16 +1,13 @@
 import fs from 'fs';
 import path from 'path';
-import { fileURLToPath } from 'url';
 import Table from 'cli-table3';
 import chalk from 'chalk';
 import Print from '../Print.js';
 import { getSrcPath, getComponentsJsPath, getConfigPath } from '../utils/PathHelper.js';
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
 /**
- * Carga la configuración desde sliceConfig.json
- * @returns {object} - Objeto de configuración
+ * Loads configuration from sliceConfig.json
+ * @returns {object} - Configuration object
  */
 const loadConfig = () => {
     try {
@@ -30,9 +27,9 @@ const loadConfig = () => {
 };
 
 /**
- * Lista los archivos en una carpeta dada, filtrando solo los archivos .js
- * @param {string} folderPath - Ruta de la carpeta a leer
- * @returns {string[]} - Lista de archivos encontrados
+ * Lists files in a given folder, filtering only .js files
+ * @param {string} folderPath - Path of the folder to read
+ * @returns {string[]} - List of found files
  */
 const listComponents = (folderPath) => {
     try {
@@ -48,7 +45,7 @@ const listComponents = (folderPath) => {
 };
 
 /**
- * Cuenta archivos en un directorio de componente
+ * Counts files in a component directory
  */
 const countComponentFiles = (componentPath) => {
     try {
@@ -61,14 +58,14 @@ const countComponentFiles = (componentPath) => {
 };
 
 /**
- * Obtiene los componentes dinámicamente desde sliceConfig.json
- * @returns {object} - Mapeo de componentes con su categoría
+ * Gets components dynamically from sliceConfig.json
+ * @returns {object} - Component mapping with their category
  */
 const getComponents = () => {
     const config = loadConfig();
     if (!config) return {};
 
-    const folderSuffix = 'src'; // Siempre usar 'src' para desarrollo
+    const folderSuffix = 'src'; // Always use 'src' for development
     const componentPaths = config.paths?.components || {};
     let allComponents = new Map();
 
@@ -91,7 +88,7 @@ const getComponents = () => {
 
 function listComponentsReal() {
     try {
-        // Obtener componentes dinámicamente
+        // Get components dynamically
         const components = getComponents();
 
         if (Object.keys(components).length === 0) {
@@ -100,7 +97,7 @@ function listComponentsReal() {
             return;
         }
 
-        // Crear tabla con cli-table3
+        // Create table with cli-table3
         const table = new Table({
             head: [
                 chalk.cyan.bold('Component'),
@@ -114,7 +111,7 @@ function listComponentsReal() {
             }
         });
 
-        // Agrupar por categoría para mejor visualización
+        // Group by category for better visualization
         const byCategory = {};
         Object.entries(components).forEach(([name, data]) => {
             if (!byCategory[data.category]) {
@@ -123,18 +120,18 @@ function listComponentsReal() {
             byCategory[data.category].push({ name, files: data.files });
         });
 
-        // Agregar filas a la tabla
+        // Add rows to the table
         Object.entries(byCategory).forEach(([category, comps]) => {
             comps.forEach((comp, index) => {
                 if (index === 0) {
-                    // Primera fila de la categoría
+                    // First row of the category
                     table.push([
                         chalk.bold(comp.name),
                         chalk.yellow(category),
                         comp.files.toString()
                     ]);
                 } else {
-                    // Resto de componentes en la categoría
+                    // Rest of components in the category
                     table.push([
                         chalk.bold(comp.name),
                         chalk.gray('″'),  // Ditto mark
@@ -151,16 +148,16 @@ function listComponentsReal() {
         Print.newLine();
         Print.info(`Total: ${Object.keys(components).length} component${Object.keys(components).length !== 1 ? 's' : ''} found`);
 
-        // Ruta donde se generará components.js
+        // Path where components.js will be generated
         const outputPath = getComponentsJsPath(import.meta.url);
 
-        // Asegurar que el directorio existe
+        // Ensure the directory exists
         const outputDir = path.dirname(outputPath);
         if (!fs.existsSync(outputDir)) {
             fs.mkdirSync(outputDir, { recursive: true });
         }
 
-        // Generar archivo components.js con los componentes detectados
+        // Generate components.js file with detected components
         const componentsForExport = Object.fromEntries(
             Object.entries(components).map(([name, data]) => [name, data.category])
         );

package/commands/startServer/startServer.js

@@ -1,19 +1,16 @@
-// commands/startServer/startServer.js - MEJORADO CON VALIDACIÓN Y FEEDBACK
+// commands/startServer/startServer.js - IMPROVED WITH VALIDATION AND FEEDBACK
 
 import fs from 'fs-extra';
 import path from 'path';
-import { fileURLToPath } from 'url';
 import { spawn } from 'child_process';
 import { createServer } from 'net';
 import setupWatcher, { stopWatcher } from './watchServer.js';
 import Print from '../Print.js';
-import { getConfigPath, getApiPath, getSrcPath, getDistPath } from '../utils/PathHelper.js';
+import { getConfigPath, getApiPath, getSrcPath, getDistPath, getPath } from '../utils/PathHelper.js';
 import build from '../build/build.js';
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
 /**
- * Carga la configuración desde sliceConfig.json
+ * Loads configuration from sliceConfig.json
  */
 const loadConfig = () => {
   try {
@@ -27,7 +24,7 @@ const loadConfig = () => {
 };
 
 /**
- * Verifica si un puerto está disponible
+ * Checks if a port is available
  */
 async function isPortAvailable(port) {
   return new Promise((resolve) => {
@@ -51,16 +48,16 @@ async function isPortAvailable(port) {
 }
 
 /**
- * Verifica si existe un build de producción
+ * Checks if a production build exists
  */
 async function checkProductionBuild() {
   const distDir = getDistPath(import.meta.url);
-  const bundleConfigPath = path.join(distDir, 'bundles', 'bundle.config.json');
+  const bundleConfigPath = getPath(import.meta.url, 'dist', 'bundles', 'bundle.config.json');
   return (await fs.pathExists(distDir)) && (await fs.pathExists(bundleConfigPath));
 }
 
 /**
- * Verifica si existe la estructura de desarrollo
+ * Checks if the development structure exists
  */
 async function checkDevelopmentStructure() {
   const srcDir = getSrcPath(import.meta.url);
@@ -70,13 +67,13 @@ async function checkDevelopmentStructure() {
 }
 
 /**
- * Inicia el servidor Node.js con argumentos y mejor feedback
+ * Starts the Node.js server with arguments and improved feedback
  */
 function startNodeServer(port, mode) {
   return new Promise((resolve, reject) => {
     const apiIndexPath = getApiPath(import.meta.url, 'index.js');
 
-    // Verificar que el archivo existe
+    // Verify the file exists
     if (!fs.existsSync(apiIndexPath)) {
       reject(new Error(`Server file not found: ${apiIndexPath}`));
       return;
@@ -84,7 +81,7 @@ function startNodeServer(port, mode) {
 
     Print.serverStatus('starting', 'Starting server...');
 
-    // Construir argumentos basados en el modo
+    // Build arguments based on mode
     const args = [apiIndexPath];
     if (mode === 'production') {
       args.push('--production');
@@ -109,12 +106,12 @@ function startNodeServer(port, mode) {
     let serverStarted = false;
     let outputBuffer = '';
 
-    // Capturar la salida para detectar cuando el servidor está listo
+    // Capture output to detect when the server is ready
     serverProcess.stdout.on('data', (data) => {
       const output = data.toString();
       outputBuffer += output;
 
-      // Detectar mensajes comunes que indican que el servidor ha iniciado
+      // Detect common messages indicating the server has started
       if (!serverStarted && (
         output.includes('Server running') ||
         output.includes('listening on') ||
@@ -125,7 +122,7 @@ function startNodeServer(port, mode) {
         Print.serverReady(port);
       }
 
-      // Mostrar la salida del servidor
+      // Display server output
       process.stdout.write(output);
     });
 
@@ -161,7 +158,7 @@ function startNodeServer(port, mode) {
       serverProcess.kill('SIGTERM');
     });
 
-    // Si después de 3 segundos no detectamos inicio, asumimos que está listo
+    // If after 3 seconds we haven't detected startup, assume it's ready
     setTimeout(() => {
       if (!serverStarted) {
         serverStarted = true;
@@ -173,7 +170,7 @@ function startNodeServer(port, mode) {
 }
 
 /**
- * Función principal para iniciar servidor
+ * Main function to start the server
  */
 export default async function startServer(options = {}) {
   const config = loadConfig();
@@ -185,7 +182,7 @@ export default async function startServer(options = {}) {
     Print.title(`🚀 Starting Slice.js ${mode} server...`);
     Print.newLine();
 
-    // Verificar estructura del proyecto
+    // Verify project structure
     if (!await checkDevelopmentStructure()) {
       throw new Error('Project structure not found. Run "slice init" first.');
     }
@@ -204,7 +201,7 @@ export default async function startServer(options = {}) {
     Print.newLine();
 
     if (mode === 'production') {
-      // Verificar que existe build de producción
+      // Verify production build exists
       if (!await checkProductionBuild()) {
         Print.info('No production build found. Running "slice build"...');
         const success = await build({});
@@ -219,10 +216,10 @@ export default async function startServer(options = {}) {
 
     Print.newLine();
 
-    // Iniciar el servidor con argumentos
+    // Start the server with arguments
     let serverProcess = await startNodeServer(actualPort, mode);
 
-    // Configurar watch mode si está habilitado
+    // Configure watch mode if enabled
     if (watch) {
       Print.newLine();
       const watcher = setupWatcher(serverProcess, async (changedPath) => {
@@ -253,12 +250,12 @@ export default async function startServer(options = {}) {
 
   } catch (error) {
     Print.newLine();
-    Print.error(error.message);
+    Print.error(`Failed to start development server: ${error.message}`);
     throw error;
   }
 }
 
 /**
- * Funciones de utilidad exportadas
+ * Exported utility functions
  */
 export { checkProductionBuild, checkDevelopmentStructure, isPortAvailable };

package/commands/startServer/watchServer.js

@@ -3,9 +3,9 @@ import chalk from 'chalk';
 import Print from '../Print.js';
 
 /**
- * Configura el watcher para archivos del proyecto
- * @param {ChildProcess} serverProcess - Proceso del servidor
- * @returns {FSWatcher} - Watcher de chokidar
+ * Configures the watcher for project files
+ * @param {ChildProcess} serverProcess - Server process
+ * @returns {FSWatcher} - Chokidar watcher
  */
 export default function setupWatcher(serverProcess, onRestart) {
     Print.info('Watch mode enabled - monitoring file changes...');
@@ -13,7 +13,7 @@ export default function setupWatcher(serverProcess, onRestart) {
 
     const watcher = chokidar.watch(['src/**/*', 'api/**/*'], {
         ignored: [
-            /(^|[\/\\])\../,  // archivos ocultos
+            /(^|[\/\\])\../,  // hidden files
             '**/node_modules/**',
             '**/dist/**',
             '**/bundles/**',
@@ -31,7 +31,7 @@ export default function setupWatcher(serverProcess, onRestart) {
 
     watcher
         .on('change', (path) => {
-            // Debounce para evitar múltiples reloads
+            // Debounce to avoid multiple reloads
             clearTimeout(reloadTimeout);
             reloadTimeout = setTimeout(() => {
                 if(onRestart) {
@@ -68,8 +68,8 @@ export default function setupWatcher(serverProcess, onRestart) {
 }
 
 /**
- * Detiene el watcher de forma segura
- * @param {FSWatcher} watcher - Watcher a detener
+ * Stops the watcher safely
+ * @param {FSWatcher} watcher - Watcher to stop
  */
 export function stopWatcher(watcher) {
     if (watcher) {

package/commands/types/types.js

@@ -4,6 +4,7 @@ import { parse } from '@babel/parser';
 import traverse from '@babel/traverse';
 
 import Print from '../Print.js';
+import { getConfigPath, getComponentsJsPath, joinRoot } from '../utils/PathHelper.js';
 
 const TYPE_MAP = {
   string: 'string',
@@ -114,22 +115,29 @@ const sortKeys = (obj) => {
     }, {});
 };
 
-const parseComponentsRegistry = (content) => {
+const parseComponentsRegistry = (content, filePath) => {
   const match = content.match(/const components = ({[\s\S]*?});/);
   if (!match) {
-    throw new Error('Invalid components.js format. Expected: const components = { ... };');
+    throw new Error(`Invalid format in ${filePath}. Expected: const components = { ... };`);
+  }
+  try {
+    return JSON.parse(match[1]);
+  } catch (parseError) {
+    throw new Error(`Failed to parse components registry in ${filePath}: ${parseError.message}`);
   }
-  return JSON.parse(match[1]);
 };
 
-const extractStaticPropsFromSource = (source) => {
+const extractStaticPropsFromSource = (source, filePath) => {
   let ast;
   try {
     ast = parse(source, {
       sourceType: 'module',
       plugins: ['classProperties']
     });
-  } catch {
+  } catch (parseError) {
+    const sourceDesc = filePath || 'unknown file';
+    const loc = parseError.loc ? ` at line ${parseError.loc.line}, column ${parseError.loc.column}` : '';
+    Print.warning(`Parse error in ${sourceDesc}${loc}: ${parseError.message}`);
     return null;
   }
 
@@ -194,7 +202,7 @@ const DEFAULT_EDITOR_EXCLUDE = ['node_modules', 'dist', 'src/libs/**', 'tests/**
 const NOISY_INCLUDE_PATTERNS = new Set(['src/**/*.js', 'api/**/*.js', 'tests/**/*.js']);
 
 const readPublicFolderExcludes = async (projectRoot) => {
-  const configPath = path.join(projectRoot, 'src', 'sliceConfig.json');
+  const configPath = getConfigPath(import.meta.url, projectRoot);
   if (!(await fs.pathExists(configPath))) return [];
 
   try {
@@ -230,7 +238,7 @@ const collectJavaScriptFiles = async (dirPath) => {
 };
 
 const ensureNoCheckInPublicVendorFiles = async (projectRoot) => {
-  const configPath = path.join(projectRoot, 'src', 'sliceConfig.json');
+  const configPath = getConfigPath(import.meta.url, projectRoot);
   if (!(await fs.pathExists(configPath))) return { updatedFiles: 0, scannedFiles: 0 };
 
   let parsed;
@@ -245,7 +253,7 @@ const ensureNoCheckInPublicVendorFiles = async (projectRoot) => {
     .map((folder) => String(folder || '').trim())
     .filter(Boolean)
     .map((folder) => folder.replace(/^[/\\]+/, ''))
-    .map((folder) => path.join(projectRoot, 'src', folder));
+    .map((folder) => joinRoot(projectRoot, 'src', folder));
 
   const uniqueDirs = Array.from(new Set(candidateDirs));
   let scannedFiles = 0;
@@ -360,9 +368,11 @@ const readCategoryPathFromConfig = async (configPath, category) => {
 };
 
 const loadComponentStaticProps = async ({ projectRoot, registryMap }) => {
-  const configPath = path.join(projectRoot, 'src', 'sliceConfig.json');
+  const configPath = getConfigPath(import.meta.url, projectRoot);
   const categoryPathCache = new Map();
   const componentPropsMap = {};
+  let skippedCount = 0;
+  let processedCount = 0;
 
   for (const [componentName, category] of Object.entries(sortKeys(registryMap))) {
     if (!categoryPathCache.has(category)) {
@@ -372,26 +382,50 @@ const loadComponentStaticProps = async ({ projectRoot, registryMap }) => {
 
     const categoryPath = categoryPathCache.get(category);
     if (!categoryPath) {
+      skippedCount++;
       continue;
     }
 
-    const componentFile = path.join(projectRoot, 'src', categoryPath, componentName, `${componentName}.js`);
+    const componentFile = joinRoot(projectRoot, 'src', categoryPath, componentName, `${componentName}.js`);
     if (!(await fs.pathExists(componentFile))) {
+      skippedCount++;
+      continue;
+    }
+
+    let source;
+    try {
+      source = await fs.readFile(componentFile, 'utf8');
+    } catch (readError) {
+      Print.warning(`Cannot read ${componentFile}: ${readError.message}`);
+      skippedCount++;
       continue;
     }
 
-    const source = await fs.readFile(componentFile, 'utf8');
-    const props = extractStaticPropsFromSource(source);
-    componentPropsMap[componentName] = props || { [DYNAMIC_FALLBACK_PROP]: { type: 'any', required: false } };
+    const props = extractStaticPropsFromSource(source, componentFile);
+    if (props) {
+      componentPropsMap[componentName] = props;
+      processedCount++;
+    } else {
+      componentPropsMap[componentName] = { [DYNAMIC_FALLBACK_PROP]: { type: 'any', required: false } };
+    }
+  }
+
+  if (skippedCount > 0) {
+    Print.info(`Skipped ${skippedCount} component(s) with missing or unreadable files`);
   }
 
   return componentPropsMap;
 };
 
 const generateTypesFile = async ({ projectRoot, outputPath }) => {
-  const registryPath = path.join(projectRoot, 'src', 'Components', 'components.js');
-  const registryContent = await fs.readFile(registryPath, 'utf8');
-  const registryMap = parseComponentsRegistry(registryContent);
+  const registryPath = getComponentsJsPath(import.meta.url, projectRoot);
+  let registryContent;
+  try {
+    registryContent = await fs.readFile(registryPath, 'utf8');
+  } catch (readError) {
+    throw new Error(`Cannot read components registry at ${registryPath}: ${readError.message}`);
+  }
+  const registryMap = parseComponentsRegistry(registryContent, registryPath);
 
   const componentPropsMap = await loadComponentStaticProps({ projectRoot, registryMap });
 
@@ -412,12 +446,12 @@ const toPosixRelative = (projectRoot, targetPath) => {
 
 const ensureEditorConfigForTypes = async ({ projectRoot, outputPath }) => {
   try {
-    const tsconfigPath = path.join(projectRoot, 'tsconfig.json');
+    const tsconfigPath = joinRoot(projectRoot, 'tsconfig.json');
     if (await fs.pathExists(tsconfigPath)) {
       return { mode: 'tsconfig_exists', filePath: tsconfigPath, includeAdded: false };
     }
 
-    const jsconfigPath = path.join(projectRoot, 'jsconfig.json');
+    const jsconfigPath = joinRoot(projectRoot, 'jsconfig.json');
     const declarationGlob = (() => {
       const relative = toPosixRelative(projectRoot, outputPath);
       if (!relative) return 'src/**/*.d.ts';
@@ -541,5 +575,6 @@ export {
   extractStaticPropsFromSource,
   generateDeclarationContent,
   generateTypesFile,
+  parseComponentsRegistry,
   runGenerateTypes
 };

package/commands/utils/PathHelper.js

@@ -59,10 +59,17 @@ export function getDistPath(moduleUrl, ...segments) {
   return joinProject(moduleUrl, 'dist', ...segments)
 }
 
-export function getConfigPath(moduleUrl) {
+export function getConfigPath(moduleUrl, root) {
+  if (root) return path.join(root, 'src', 'sliceConfig.json')
   return joinProject(moduleUrl, 'src', 'sliceConfig.json')
 }
 
-export function getComponentsJsPath(moduleUrl) {
+export function getComponentsJsPath(moduleUrl, root) {
+  if (root) return path.join(root, 'src', 'Components', 'components.js')
   return joinProject(moduleUrl, 'src', 'Components', 'components.js')
 }
+
+export function joinRoot(root, ...segments) {
+  const clean = segments.map(sanitize)
+  return path.join(root, ...clean)
+}

package/commands/utils/VersionChecker.js

@@ -4,7 +4,7 @@ import fs from "fs-extra";
 import path from "path";
 import { fileURLToPath } from "url";
 import Print from "../Print.js";
-import { getProjectRoot } from "../utils/PathHelper.js";
+import { getProjectRoot, getPath } from "../utils/PathHelper.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -25,14 +25,14 @@ class VersionChecker {
 
       // Get Framework version from project node_modules
       const projectRoot = getProjectRoot(import.meta.url);
-      const frameworkPackagePath = path.join(projectRoot, 'node_modules', 'slicejs-web-framework', 'package.json');
+      const frameworkPackagePath = getPath(import.meta.url, 'node_modules', 'slicejs-web-framework', 'package.json');
       if (await fs.pathExists(frameworkPackagePath)) {
         const frameworkPackage = await fs.readJson(frameworkPackagePath);
         this.currentFrameworkVersion = frameworkPackage.version;
       }
 
       // Get Project's CLI version
-      const projectPackagePath = path.join(__dirname, '../../../../package.json');
+      const projectPackagePath = getPath(import.meta.url, 'package.json');
       if (await fs.pathExists(projectPackagePath)) {
         const projectPackage = await fs.readJson(projectPackagePath);
         if (projectPackage.dependencies && projectPackage.dependencies['slicejs-cli']) {

package/commands/utils/bundling/DependencyAnalyzer.js

@@ -3,21 +3,13 @@ import fs from 'fs-extra';
 import path from 'path';
 import { parse } from '@babel/parser';
 import traverse from '@babel/traverse';
-import { getSrcPath, getComponentsJsPath, getProjectRoot, getConfigPath } from '../PathHelper.js';
+import { getSrcPath, getComponentsJsPath, getConfigPath, getPath } from '../PathHelper.js';
 
 export default class DependencyAnalyzer {
   constructor(moduleUrl) {
     this.moduleUrl = moduleUrl;
-    this.projectRoot = getProjectRoot(moduleUrl);
     this.componentsPath = path.dirname(getComponentsJsPath(moduleUrl));
-    this.frameworkComponentsPath = path.join(
-      this.projectRoot,
-      'node_modules',
-      'slicejs-web-framework',
-      'Slice',
-      'Components',
-      'Structural'
-    );
+    this.frameworkComponentsPath = getPath(moduleUrl, 'node_modules', 'slicejs-web-framework', 'Slice', 'Components', 'Structural');
     this.routesPath = getSrcPath(moduleUrl, 'routes.js');
 
     // Analysis storage
@@ -229,7 +221,7 @@ export default class DependencyAnalyzer {
     if (!await fs.pathExists(this.frameworkComponentsPath)) {
       return;
     }
-    const frameworkConfigPath = path.join(this.projectRoot, 'src', 'sliceConfig.json');
+    const frameworkConfigPath = getConfigPath(this.moduleUrl);
     let frameworkConfig = {};
     try {
       frameworkConfig = await fs.readJson(frameworkConfigPath);
@@ -723,7 +715,7 @@ export default class DependencyAnalyzer {
    */
   async analyzeRoutes() {
     if (!await fs.pathExists(this.routesPath)) {
-      throw new Error('routes.js no encontrado');
+      throw new Error(`routes.js not found at expected path: ${this.routesPath}. Ensure your routes.js file exists in the src directory.`);
     }
 
     const content = await fs.readFile(this.routesPath, 'utf-8');
@@ -735,11 +727,11 @@ export default class DependencyAnalyzer {
       });
 
       let currentRoute = null;
-      const self = this; // Guardar referencia a la instancia
+      const self = this; // Save reference to instance
 
       traverse.default(ast, {
         ObjectExpression(path) {
-          // Buscar objetos de ruta: { path: '/', component: 'HomePage' }
+          // Look for route objects: { path: '/', component: 'HomePage' }
           const properties = path.node.properties;
           const pathProp = properties.find(p => p.key?.name === 'path');
           const componentProp = properties.find(p => p.key?.name === 'component');
@@ -756,7 +748,7 @@ export default class DependencyAnalyzer {
 
             self.routes.set(routePath, currentRoute);
 
-            // Marcar el componente como usado por esta ruta
+            // Mark the component as used by this route
             if (self.components.has(componentName)) {
               self.components.get(componentName).routes.add(routePath);
             }
@@ -768,7 +760,7 @@ export default class DependencyAnalyzer {
       this.routeGroups = this.detectRouteGroups();
 
     } catch (error) {
-      console.warn(`⚠️  Error parseando rutas: ${error.message}`);
+      console.warn(`⚠️  Error parsing routes at ${this.routesPath}: ${error.message}`);
     }
   }
 

package/commands/utils/loadConfig.js

@@ -0,0 +1,31 @@
+import fs from 'fs-extra';
+import { getConfigPath } from './PathHelper.js';
+import Print from '../Print.js';
+
+export async function loadConfig(moduleUrl) {
+  try {
+    const configPath = getConfigPath(moduleUrl);
+    if (!await fs.pathExists(configPath)) {
+      return null;
+    }
+    const rawData = await fs.readFile(configPath, 'utf-8');
+    return JSON.parse(rawData);
+  } catch (error) {
+    Print.error(`Error loading configuration: ${error.message}`);
+    return null;
+  }
+}
+
+export function loadConfigSync(moduleUrl) {
+  try {
+    const configPath = getConfigPath(moduleUrl);
+    if (!fs.existsSync(configPath)) {
+      return null;
+    }
+    const rawData = fs.readFileSync(configPath, 'utf-8');
+    return JSON.parse(rawData);
+  } catch (error) {
+    Print.error(`Error loading configuration: ${error.message}`);
+    return null;
+  }
+}

package/commands/utils/updateManager.js

@@ -6,7 +6,7 @@ import inquirer from "inquirer";
 import ora from "ora";
 import Print from "../Print.js";
 import versionChecker from "./VersionChecker.js";
-import { getProjectRoot } from "../utils/PathHelper.js";
+import { getProjectRoot, getApiPath, getPath } from "../utils/PathHelper.js";
 import path from "path";
 import { fileURLToPath } from "url";
 import fs from "fs-extra";
@@ -401,9 +401,8 @@ export class UpdateManager {
 
     async updateApiIndexIfNeeded(options = {}) {
         try {
-            const projectRoot = getProjectRoot(import.meta.url);
-            const projectApiPath = path.join(projectRoot, 'api', 'index.js');
-            const frameworkApiPath = path.join(projectRoot, 'node_modules', 'slicejs-web-framework', 'api', 'index.js');
+            const projectApiPath = getApiPath(import.meta.url, 'index.js');
+            const frameworkApiPath = getPath(import.meta.url, 'node_modules', 'slicejs-web-framework', 'api', 'index.js');
 
             if (!await fs.pathExists(projectApiPath) || !await fs.pathExists(frameworkApiPath)) {
                 return;