@nexical/cli 0.11.8 → 0.11.10

package/dist/src/commands/module/update.js

@@ -26,12 +26,24 @@ var ModuleUpdateCommand = class extends BaseCommand {
     logger.debug("Update context:", { name, projectRoot });
     try {
       if (name) {
-        const relativePath = `modules/${name}`;
-        const fullPath = path.resolve(projectRoot, relativePath);
-        if (!await import_fs_extra.default.pathExists(fullPath)) {
+        const locations = [
+          { type: "backend", path: `apps/backend/modules/${name}` },
+          { type: "frontend", path: `apps/frontend/modules/${name}` },
+          { type: "legacy", path: `modules/${name}` }
+        ];
+        let targetLoc = null;
+        for (const loc of locations) {
+          const absPath = path.resolve(projectRoot, loc.path);
+          if (await import_fs_extra.default.pathExists(absPath)) {
+            targetLoc = loc;
+            break;
+          }
+        }
+        if (!targetLoc) {
           this.error(`Module ${name} not found.`);
           return;
         }
+        const relativePath = targetLoc.path;
         await runCommand(`git submodule update --remote --merge ${relativePath}`, projectRoot);
       } else {
         await runCommand("git submodule update --remote --merge", projectRoot);

package/dist/src/commands/module/update.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/commands/module/update.ts"],"sourcesContent":["import { type CommandDefinition, BaseCommand, logger, runCommand } from '@nexical/cli-core';\nimport fs from 'fs-extra';\nimport path from 'path';\n\nexport default class ModuleUpdateCommand extends BaseCommand {\n  static usage = 'module update [name]';\n  static description = 'Update a specific module or all modules.';\n  static requiresProject = true;\n\n  static args: CommandDefinition = {\n    args: [{ name: 'name', required: false, description: 'Name of the module to update' }],\n  };\n\n  async run(options: { name?: string }) {\n    const projectRoot = this.projectRoot as string;\n    const { name } = options;\n\n    this.info(name ? `Updating module ${name}...` : 'Updating all modules...');\n    logger.debug('Update context:', { name, projectRoot: projectRoot });\n\n    try {\n      if (name) {\n        const relativePath = `modules/${name}`;\n        const fullPath = path.resolve(projectRoot, relativePath);\n\n        if (!(await fs.pathExists(fullPath))) {\n          this.error(`Module ${name} not found.`);\n          return;\n        }\n\n        // Update specific module\n        // We enter the directory and pull? Or generic submodule update?\n        // Generic submodule update --remote src/modules/name\n        await runCommand(`git submodule update --remote --merge ${relativePath}`, projectRoot);\n      } else {\n        // Update all\n        await runCommand('git submodule update --remote --merge', projectRoot);\n      }\n\n      this.info('Syncing workspace dependencies...');\n      await runCommand('npm install', projectRoot);\n\n      this.success('Modules updated successfully.');\n    } catch (e: unknown) {\n      if (e instanceof Error) {\n        this.error(`Failed to update modules: ${e.message}`);\n      } else {\n        this.error(`Failed to update modules: ${String(e)}`);\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;AAAA;AACA,sBAAe;AADf,SAAiC,aAAa,QAAQ,kBAAkB;AAExE,OAAO,UAAU;AAEjB,IAAqB,sBAArB,cAAiD,YAAY;AAAA,EAC3D,OAAO,QAAQ;AAAA,EACf,OAAO,cAAc;AAAA,EACrB,OAAO,kBAAkB;AAAA,EAEzB,OAAO,OAA0B;AAAA,IAC/B,MAAM,CAAC,EAAE,MAAM,QAAQ,UAAU,OAAO,aAAa,+BAA+B,CAAC;AAAA,EACvF;AAAA,EAEA,MAAM,IAAI,SAA4B;AACpC,UAAM,cAAc,KAAK;AACzB,UAAM,EAAE,KAAK,IAAI;AAEjB,SAAK,KAAK,OAAO,mBAAmB,IAAI,QAAQ,yBAAyB;AACzE,WAAO,MAAM,mBAAmB,EAAE,MAAM,YAAyB,CAAC;AAElE,QAAI;AACF,UAAI,MAAM;AACR,cAAM,eAAe,WAAW,IAAI;AACpC,cAAM,WAAW,KAAK,QAAQ,aAAa,YAAY;AAEvD,YAAI,CAAE,MAAM,gBAAAA,QAAG,WAAW,QAAQ,GAAI;AACpC,eAAK,MAAM,UAAU,IAAI,aAAa;AACtC;AAAA,QACF;AAKA,cAAM,WAAW,yCAAyC,YAAY,IAAI,WAAW;AAAA,MACvF,OAAO;AAEL,cAAM,WAAW,yCAAyC,WAAW;AAAA,MACvE;AAEA,WAAK,KAAK,mCAAmC;AAC7C,YAAM,WAAW,eAAe,WAAW;AAE3C,WAAK,QAAQ,+BAA+B;AAAA,IAC9C,SAAS,GAAY;AACnB,UAAI,aAAa,OAAO;AACtB,aAAK,MAAM,6BAA6B,EAAE,OAAO,EAAE;AAAA,MACrD,OAAO;AACL,aAAK,MAAM,6BAA6B,OAAO,CAAC,CAAC,EAAE;AAAA,MACrD;AAAA,IACF;AAAA,EACF;AACF;","names":["fs"]}
+{"version":3,"sources":["../../../../src/commands/module/update.ts"],"sourcesContent":["import { type CommandDefinition, BaseCommand, logger, runCommand } from '@nexical/cli-core';\nimport fs from 'fs-extra';\nimport path from 'path';\n\nexport default class ModuleUpdateCommand extends BaseCommand {\n  static usage = 'module update [name]';\n  static description = 'Update a specific module or all modules.';\n  static requiresProject = true;\n\n  static args: CommandDefinition = {\n    args: [{ name: 'name', required: false, description: 'Name of the module to update' }],\n  };\n\n  async run(options: { name?: string }) {\n    const projectRoot = this.projectRoot as string;\n    const { name } = options;\n\n    this.info(name ? `Updating module ${name}...` : 'Updating all modules...');\n    logger.debug('Update context:', { name, projectRoot: projectRoot });\n\n    try {\n      if (name) {\n        // Check locations\n        const locations = [\n          { type: 'backend', path: `apps/backend/modules/${name}` },\n          { type: 'frontend', path: `apps/frontend/modules/${name}` },\n          { type: 'legacy', path: `modules/${name}` },\n        ];\n\n        let targetLoc: { type: string; path: string } | null = null;\n\n        for (const loc of locations) {\n          const absPath = path.resolve(projectRoot, loc.path);\n          if (await fs.pathExists(absPath)) {\n            targetLoc = loc;\n            break;\n          }\n        }\n\n        if (!targetLoc) {\n          this.error(`Module ${name} not found.`);\n          return;\n        }\n\n        const relativePath = targetLoc.path;\n\n        // Update specific module\n        await runCommand(`git submodule update --remote --merge ${relativePath}`, projectRoot);\n      } else {\n        // Update all\n        await runCommand('git submodule update --remote --merge', projectRoot);\n      }\n\n      this.info('Syncing workspace dependencies...');\n      await runCommand('npm install', projectRoot);\n\n      this.success('Modules updated successfully.');\n    } catch (e: unknown) {\n      if (e instanceof Error) {\n        this.error(`Failed to update modules: ${e.message}`);\n      } else {\n        this.error(`Failed to update modules: ${String(e)}`);\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;AAAA;AACA,sBAAe;AADf,SAAiC,aAAa,QAAQ,kBAAkB;AAExE,OAAO,UAAU;AAEjB,IAAqB,sBAArB,cAAiD,YAAY;AAAA,EAC3D,OAAO,QAAQ;AAAA,EACf,OAAO,cAAc;AAAA,EACrB,OAAO,kBAAkB;AAAA,EAEzB,OAAO,OAA0B;AAAA,IAC/B,MAAM,CAAC,EAAE,MAAM,QAAQ,UAAU,OAAO,aAAa,+BAA+B,CAAC;AAAA,EACvF;AAAA,EAEA,MAAM,IAAI,SAA4B;AACpC,UAAM,cAAc,KAAK;AACzB,UAAM,EAAE,KAAK,IAAI;AAEjB,SAAK,KAAK,OAAO,mBAAmB,IAAI,QAAQ,yBAAyB;AACzE,WAAO,MAAM,mBAAmB,EAAE,MAAM,YAAyB,CAAC;AAElE,QAAI;AACF,UAAI,MAAM;AAER,cAAM,YAAY;AAAA,UAChB,EAAE,MAAM,WAAW,MAAM,wBAAwB,IAAI,GAAG;AAAA,UACxD,EAAE,MAAM,YAAY,MAAM,yBAAyB,IAAI,GAAG;AAAA,UAC1D,EAAE,MAAM,UAAU,MAAM,WAAW,IAAI,GAAG;AAAA,QAC5C;AAEA,YAAI,YAAmD;AAEvD,mBAAW,OAAO,WAAW;AAC3B,gBAAM,UAAU,KAAK,QAAQ,aAAa,IAAI,IAAI;AAClD,cAAI,MAAM,gBAAAA,QAAG,WAAW,OAAO,GAAG;AAChC,wBAAY;AACZ;AAAA,UACF;AAAA,QACF;AAEA,YAAI,CAAC,WAAW;AACd,eAAK,MAAM,UAAU,IAAI,aAAa;AACtC;AAAA,QACF;AAEA,cAAM,eAAe,UAAU;AAG/B,cAAM,WAAW,yCAAyC,YAAY,IAAI,WAAW;AAAA,MACvF,OAAO;AAEL,cAAM,WAAW,yCAAyC,WAAW;AAAA,MACvE;AAEA,WAAK,KAAK,mCAAmC;AAC7C,YAAM,WAAW,eAAe,WAAW;AAE3C,WAAK,QAAQ,+BAA+B;AAAA,IAC9C,SAAS,GAAY;AACnB,UAAI,aAAa,OAAO;AACtB,aAAK,MAAM,6BAA6B,EAAE,OAAO,EAAE;AAAA,MACrD,OAAO;AACL,aAAK,MAAM,6BAA6B,OAAO,CAAC,CAAC,EAAE;AAAA,MACrD;AAAA,IACF;AAAA,EACF;AACF;","names":["fs"]}

package/dist/src/commands/run.js

@@ -41,8 +41,25 @@ var RunCommand = class extends BaseCommand {
     let scriptName = script;
     if (script.includes(":")) {
       const [moduleName, name] = script.split(":");
-      execPath = path.resolve(projectRoot, "modules", moduleName);
       scriptName = name;
+      const locations = [
+        { type: "backend", path: `apps/backend/modules/${moduleName}` },
+        { type: "frontend", path: `apps/frontend/modules/${moduleName}` },
+        { type: "legacy", path: `modules/${moduleName}` }
+      ];
+      let found = false;
+      for (const loc of locations) {
+        const absPath = path.resolve(projectRoot, loc.path);
+        if (await import_fs_extra.default.pathExists(absPath)) {
+          execPath = absPath;
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        this.error(`Module ${moduleName} not found.`);
+        return;
+      }
       logger.debug(`Resolving module script: ${moduleName}:${scriptName} at ${execPath}`);
     } else {
       logger.debug(`Resolving core script: ${scriptName} at ${execPath}`);

package/dist/src/commands/run.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/commands/run.ts"],"sourcesContent":["import { type CommandDefinition, BaseCommand, logger } from '@nexical/cli-core';\nimport fs from 'fs-extra';\nimport path from 'path';\nimport { spawn } from 'child_process';\nimport process from 'node:process';\n\nexport default class RunCommand extends BaseCommand {\n  static usage = 'run <script> [args...]';\n  static description = 'Run a script inside the Nexical environment.';\n  static requiresProject = true;\n\n  static args: CommandDefinition = {\n    args: [\n      {\n        name: 'script',\n        required: true,\n        description: 'The script to run (script-name OR module:script-name)',\n      },\n      { name: 'args...', required: false, description: 'Arguments for the script' },\n    ],\n  };\n\n  async run(options: { script: string; args?: string[] }) {\n    const projectRoot = this.projectRoot as string;\n    const script = options.script;\n    const scriptArgs = options.args || [];\n\n    if (!script) {\n      this.error('Please specify a script to run.');\n      return;\n    }\n\n    logger.debug('Run command context:', { script, args: scriptArgs, projectRoot });\n\n    let execPath = projectRoot;\n    let scriptName = script;\n\n    // Handle module:script syntax\n    if (script.includes(':')) {\n      const [moduleName, name] = script.split(':');\n      execPath = path.resolve(projectRoot, 'modules', moduleName);\n      scriptName = name;\n\n      logger.debug(`Resolving module script: ${moduleName}:${scriptName} at ${execPath}`);\n    } else {\n      logger.debug(`Resolving core script: ${scriptName} at ${execPath}`);\n    }\n\n    // Validate script existence\n    const pkgJsonPath = path.join(execPath, 'package.json');\n    if (!(await fs.pathExists(pkgJsonPath))) {\n      this.error(`Failed to find package.json at ${execPath}`);\n      return;\n    }\n\n    try {\n      const pkg = await fs.readJson(pkgJsonPath);\n      if (!pkg.scripts || !pkg.scripts[scriptName]) {\n        const type = script.includes(':') ? `module ${script.split(':')[0]}` : 'Nexical core';\n        this.error(`Script \"${scriptName}\" does not exist in ${type}`);\n        return;\n      }\n    } catch (e: unknown) {\n      if (e instanceof Error) {\n        this.error(`Failed to read package.json at ${execPath}: ${e.message}`);\n      } else {\n        this.error(`Failed to read package.json at ${execPath}: ${String(e)}`);\n      }\n      return;\n    }\n\n    const finalArgs = ['run', scriptName, '--', ...scriptArgs];\n    logger.debug(`Executing: npm ${finalArgs.join(' ')} in ${execPath}`);\n\n    const child = spawn('npm', finalArgs, {\n      cwd: execPath,\n      stdio: 'inherit',\n      env: {\n        ...process.env,\n        FORCE_COLOR: '1',\n      },\n    });\n\n    // Handle process termination to kill child\n    const cleanup = () => {\n      child.kill();\n      process.exit();\n    };\n\n    process.on('SIGINT', cleanup);\n    process.on('SIGTERM', cleanup);\n\n    await new Promise<void>((resolve) => {\n      child.on('close', (code) => {\n        // Remove listeners to prevent memory leaks if this command is run multiple times in-process (e.g. tests)\n        process.off('SIGINT', cleanup);\n        process.off('SIGTERM', cleanup);\n\n        if (code !== 0) {\n          process.exit(code || 1);\n        }\n        resolve();\n      });\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;AAAA;AACA,sBAAe;AADf,SAAiC,aAAa,cAAc;AAE5D,OAAO,UAAU;AACjB,SAAS,aAAa;AACtB,OAAO,aAAa;AAEpB,IAAqB,aAArB,cAAwC,YAAY;AAAA,EAClD,OAAO,QAAQ;AAAA,EACf,OAAO,cAAc;AAAA,EACrB,OAAO,kBAAkB;AAAA,EAEzB,OAAO,OAA0B;AAAA,IAC/B,MAAM;AAAA,MACJ;AAAA,QACE,MAAM;AAAA,QACN,UAAU;AAAA,QACV,aAAa;AAAA,MACf;AAAA,MACA,EAAE,MAAM,WAAW,UAAU,OAAO,aAAa,2BAA2B;AAAA,IAC9E;AAAA,EACF;AAAA,EAEA,MAAM,IAAI,SAA8C;AACtD,UAAM,cAAc,KAAK;AACzB,UAAM,SAAS,QAAQ;AACvB,UAAM,aAAa,QAAQ,QAAQ,CAAC;AAEpC,QAAI,CAAC,QAAQ;AACX,WAAK,MAAM,iCAAiC;AAC5C;AAAA,IACF;AAEA,WAAO,MAAM,wBAAwB,EAAE,QAAQ,MAAM,YAAY,YAAY,CAAC;AAE9E,QAAI,WAAW;AACf,QAAI,aAAa;AAGjB,QAAI,OAAO,SAAS,GAAG,GAAG;AACxB,YAAM,CAAC,YAAY,IAAI,IAAI,OAAO,MAAM,GAAG;AAC3C,iBAAW,KAAK,QAAQ,aAAa,WAAW,UAAU;AAC1D,mBAAa;AAEb,aAAO,MAAM,4BAA4B,UAAU,IAAI,UAAU,OAAO,QAAQ,EAAE;AAAA,IACpF,OAAO;AACL,aAAO,MAAM,0BAA0B,UAAU,OAAO,QAAQ,EAAE;AAAA,IACpE;AAGA,UAAM,cAAc,KAAK,KAAK,UAAU,cAAc;AACtD,QAAI,CAAE,MAAM,gBAAAA,QAAG,WAAW,WAAW,GAAI;AACvC,WAAK,MAAM,kCAAkC,QAAQ,EAAE;AACvD;AAAA,IACF;AAEA,QAAI;AACF,YAAM,MAAM,MAAM,gBAAAA,QAAG,SAAS,WAAW;AACzC,UAAI,CAAC,IAAI,WAAW,CAAC,IAAI,QAAQ,UAAU,GAAG;AAC5C,cAAM,OAAO,OAAO,SAAS,GAAG,IAAI,UAAU,OAAO,MAAM,GAAG,EAAE,CAAC,CAAC,KAAK;AACvE,aAAK,MAAM,WAAW,UAAU,uBAAuB,IAAI,EAAE;AAC7D;AAAA,MACF;AAAA,IACF,SAAS,GAAY;AACnB,UAAI,aAAa,OAAO;AACtB,aAAK,MAAM,kCAAkC,QAAQ,KAAK,EAAE,OAAO,EAAE;AAAA,MACvE,OAAO;AACL,aAAK,MAAM,kCAAkC,QAAQ,KAAK,OAAO,CAAC,CAAC,EAAE;AAAA,MACvE;AACA;AAAA,IACF;AAEA,UAAM,YAAY,CAAC,OAAO,YAAY,MAAM,GAAG,UAAU;AACzD,WAAO,MAAM,kBAAkB,UAAU,KAAK,GAAG,CAAC,OAAO,QAAQ,EAAE;AAEnE,UAAM,QAAQ,MAAM,OAAO,WAAW;AAAA,MACpC,KAAK;AAAA,MACL,OAAO;AAAA,MACP,KAAK;AAAA,QACH,GAAG,QAAQ;AAAA,QACX,aAAa;AAAA,MACf;AAAA,IACF,CAAC;AAGD,UAAM,UAAU,MAAM;AACpB,YAAM,KAAK;AACX,cAAQ,KAAK;AAAA,IACf;AAEA,YAAQ,GAAG,UAAU,OAAO;AAC5B,YAAQ,GAAG,WAAW,OAAO;AAE7B,UAAM,IAAI,QAAc,CAAC,YAAY;AACnC,YAAM,GAAG,SAAS,CAAC,SAAS;AAE1B,gBAAQ,IAAI,UAAU,OAAO;AAC7B,gBAAQ,IAAI,WAAW,OAAO;AAE9B,YAAI,SAAS,GAAG;AACd,kBAAQ,KAAK,QAAQ,CAAC;AAAA,QACxB;AACA,gBAAQ;AAAA,MACV,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AACF;","names":["fs"]}
+{"version":3,"sources":["../../../src/commands/run.ts"],"sourcesContent":["import { type CommandDefinition, BaseCommand, logger } from '@nexical/cli-core';\nimport fs from 'fs-extra';\nimport path from 'path';\nimport { spawn } from 'child_process';\nimport process from 'node:process';\n\nexport default class RunCommand extends BaseCommand {\n  static usage = 'run <script> [args...]';\n  static description = 'Run a script inside the Nexical environment.';\n  static requiresProject = true;\n\n  static args: CommandDefinition = {\n    args: [\n      {\n        name: 'script',\n        required: true,\n        description: 'The script to run (script-name OR module:script-name)',\n      },\n      { name: 'args...', required: false, description: 'Arguments for the script' },\n    ],\n  };\n\n  async run(options: { script: string; args?: string[] }) {\n    const projectRoot = this.projectRoot as string;\n    const script = options.script;\n    const scriptArgs = options.args || [];\n\n    if (!script) {\n      this.error('Please specify a script to run.');\n      return;\n    }\n\n    logger.debug('Run command context:', { script, args: scriptArgs, projectRoot });\n\n    let execPath = projectRoot;\n    let scriptName = script;\n\n    // Handle module:script syntax\n    if (script.includes(':')) {\n      const [moduleName, name] = script.split(':');\n      scriptName = name;\n\n      const locations = [\n        { type: 'backend', path: `apps/backend/modules/${moduleName}` },\n        { type: 'frontend', path: `apps/frontend/modules/${moduleName}` },\n        { type: 'legacy', path: `modules/${moduleName}` },\n      ];\n\n      let found = false;\n      for (const loc of locations) {\n        const absPath = path.resolve(projectRoot, loc.path);\n        if (await fs.pathExists(absPath)) {\n          execPath = absPath;\n          found = true;\n          break;\n        }\n      }\n\n      if (!found) {\n        this.error(`Module ${moduleName} not found.`);\n        return;\n      }\n\n      logger.debug(`Resolving module script: ${moduleName}:${scriptName} at ${execPath}`);\n    } else {\n      logger.debug(`Resolving core script: ${scriptName} at ${execPath}`);\n    }\n\n    // Validate script existence\n    const pkgJsonPath = path.join(execPath, 'package.json');\n    if (!(await fs.pathExists(pkgJsonPath))) {\n      this.error(`Failed to find package.json at ${execPath}`);\n      return;\n    }\n\n    try {\n      const pkg = await fs.readJson(pkgJsonPath);\n      if (!pkg.scripts || !pkg.scripts[scriptName]) {\n        const type = script.includes(':') ? `module ${script.split(':')[0]}` : 'Nexical core';\n        this.error(`Script \"${scriptName}\" does not exist in ${type}`);\n        return;\n      }\n    } catch (e: unknown) {\n      if (e instanceof Error) {\n        this.error(`Failed to read package.json at ${execPath}: ${e.message}`);\n      } else {\n        this.error(`Failed to read package.json at ${execPath}: ${String(e)}`);\n      }\n      return;\n    }\n\n    const finalArgs = ['run', scriptName, '--', ...scriptArgs];\n    logger.debug(`Executing: npm ${finalArgs.join(' ')} in ${execPath}`);\n\n    const child = spawn('npm', finalArgs, {\n      cwd: execPath,\n      stdio: 'inherit',\n      env: {\n        ...process.env,\n        FORCE_COLOR: '1',\n      },\n    });\n\n    // Handle process termination to kill child\n    const cleanup = () => {\n      child.kill();\n      process.exit();\n    };\n\n    process.on('SIGINT', cleanup);\n    process.on('SIGTERM', cleanup);\n\n    await new Promise<void>((resolve) => {\n      child.on('close', (code) => {\n        // Remove listeners to prevent memory leaks if this command is run multiple times in-process (e.g. tests)\n        process.off('SIGINT', cleanup);\n        process.off('SIGTERM', cleanup);\n\n        if (code !== 0) {\n          process.exit(code || 1);\n        }\n        resolve();\n      });\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;AAAA;AACA,sBAAe;AADf,SAAiC,aAAa,cAAc;AAE5D,OAAO,UAAU;AACjB,SAAS,aAAa;AACtB,OAAO,aAAa;AAEpB,IAAqB,aAArB,cAAwC,YAAY;AAAA,EAClD,OAAO,QAAQ;AAAA,EACf,OAAO,cAAc;AAAA,EACrB,OAAO,kBAAkB;AAAA,EAEzB,OAAO,OAA0B;AAAA,IAC/B,MAAM;AAAA,MACJ;AAAA,QACE,MAAM;AAAA,QACN,UAAU;AAAA,QACV,aAAa;AAAA,MACf;AAAA,MACA,EAAE,MAAM,WAAW,UAAU,OAAO,aAAa,2BAA2B;AAAA,IAC9E;AAAA,EACF;AAAA,EAEA,MAAM,IAAI,SAA8C;AACtD,UAAM,cAAc,KAAK;AACzB,UAAM,SAAS,QAAQ;AACvB,UAAM,aAAa,QAAQ,QAAQ,CAAC;AAEpC,QAAI,CAAC,QAAQ;AACX,WAAK,MAAM,iCAAiC;AAC5C;AAAA,IACF;AAEA,WAAO,MAAM,wBAAwB,EAAE,QAAQ,MAAM,YAAY,YAAY,CAAC;AAE9E,QAAI,WAAW;AACf,QAAI,aAAa;AAGjB,QAAI,OAAO,SAAS,GAAG,GAAG;AACxB,YAAM,CAAC,YAAY,IAAI,IAAI,OAAO,MAAM,GAAG;AAC3C,mBAAa;AAEb,YAAM,YAAY;AAAA,QAChB,EAAE,MAAM,WAAW,MAAM,wBAAwB,UAAU,GAAG;AAAA,QAC9D,EAAE,MAAM,YAAY,MAAM,yBAAyB,UAAU,GAAG;AAAA,QAChE,EAAE,MAAM,UAAU,MAAM,WAAW,UAAU,GAAG;AAAA,MAClD;AAEA,UAAI,QAAQ;AACZ,iBAAW,OAAO,WAAW;AAC3B,cAAM,UAAU,KAAK,QAAQ,aAAa,IAAI,IAAI;AAClD,YAAI,MAAM,gBAAAA,QAAG,WAAW,OAAO,GAAG;AAChC,qBAAW;AACX,kBAAQ;AACR;AAAA,QACF;AAAA,MACF;AAEA,UAAI,CAAC,OAAO;AACV,aAAK,MAAM,UAAU,UAAU,aAAa;AAC5C;AAAA,MACF;AAEA,aAAO,MAAM,4BAA4B,UAAU,IAAI,UAAU,OAAO,QAAQ,EAAE;AAAA,IACpF,OAAO;AACL,aAAO,MAAM,0BAA0B,UAAU,OAAO,QAAQ,EAAE;AAAA,IACpE;AAGA,UAAM,cAAc,KAAK,KAAK,UAAU,cAAc;AACtD,QAAI,CAAE,MAAM,gBAAAA,QAAG,WAAW,WAAW,GAAI;AACvC,WAAK,MAAM,kCAAkC,QAAQ,EAAE;AACvD;AAAA,IACF;AAEA,QAAI;AACF,YAAM,MAAM,MAAM,gBAAAA,QAAG,SAAS,WAAW;AACzC,UAAI,CAAC,IAAI,WAAW,CAAC,IAAI,QAAQ,UAAU,GAAG;AAC5C,cAAM,OAAO,OAAO,SAAS,GAAG,IAAI,UAAU,OAAO,MAAM,GAAG,EAAE,CAAC,CAAC,KAAK;AACvE,aAAK,MAAM,WAAW,UAAU,uBAAuB,IAAI,EAAE;AAC7D;AAAA,MACF;AAAA,IACF,SAAS,GAAY;AACnB,UAAI,aAAa,OAAO;AACtB,aAAK,MAAM,kCAAkC,QAAQ,KAAK,EAAE,OAAO,EAAE;AAAA,MACvE,OAAO;AACL,aAAK,MAAM,kCAAkC,QAAQ,KAAK,OAAO,CAAC,CAAC,EAAE;AAAA,MACvE;AACA;AAAA,IACF;AAEA,UAAM,YAAY,CAAC,OAAO,YAAY,MAAM,GAAG,UAAU;AACzD,WAAO,MAAM,kBAAkB,UAAU,KAAK,GAAG,CAAC,OAAO,QAAQ,EAAE;AAEnE,UAAM,QAAQ,MAAM,OAAO,WAAW;AAAA,MACpC,KAAK;AAAA,MACL,OAAO;AAAA,MACP,KAAK;AAAA,QACH,GAAG,QAAQ;AAAA,QACX,aAAa;AAAA,MACf;AAAA,IACF,CAAC;AAGD,UAAM,UAAU,MAAM;AACpB,YAAM,KAAK;AACX,cAAQ,KAAK;AAAA,IACf;AAEA,YAAQ,GAAG,UAAU,OAAO;AAC5B,YAAQ,GAAG,WAAW,OAAO;AAE7B,UAAM,IAAI,QAAc,CAAC,YAAY;AACnC,YAAM,GAAG,SAAS,CAAC,SAAS;AAE1B,gBAAQ,IAAI,UAAU,OAAO;AAC7B,gBAAQ,IAAI,WAAW,OAAO;AAE9B,YAAI,SAAS,GAAG;AACd,kBAAQ,KAAK,QAAQ,CAAC;AAAA,QACxB;AACA,gBAAQ;AAAA,MACV,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AACF;","names":["fs"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nexical/cli",
-  "version": "0.11.8",
+  "version": "0.11.10",
   "type": "module",
   "bin": {
     "nexical": "./dist/index.js"
@@ -28,7 +28,7 @@
     ]
   },
   "dependencies": {
-    "@nexical/cli-core": "^0.1.12",
+    "@nexical/cli-core": "^0.1.15",
     "dotenv": "^17.3.1",
     "fast-glob": "^3.3.3",
     "jiti": "^2.6.1",

package/src/commands/deploy.ts

@@ -6,9 +6,9 @@ import { ProviderRegistry } from '../deploy/registry';
 import { DeploymentContext } from '../deploy/types';
 
 export default class DeployCommand extends BaseCommand {
-  static description = `Deploy the application based on nexical.yaml configuration.
-
-This command orchestrates the deployment of your frontend and backend applications 
+  static usage = 'deploy';
+  static description = 'Deploy the application based on nexical.yaml configuration.';
+  static help = `This command orchestrates the deployment of your frontend and backend applications 
 by interacting with the providers specified in your configuration file.
 
 CONFIGURATION:

package/src/commands/module/add.ts

@@ -66,6 +66,7 @@ export default class ModuleAddCommand extends BaseCommand {
       `staging-${Date.now()}-${Math.random().toString(36).substring(7)}`,
     );
     let moduleName = '';
+    let moduleType: 'backend' | 'frontend' = 'backend'; // Default to backend if uncertain, but we should detect.
     let dependencies: string[] = [];
 
     try {
@@ -74,28 +75,68 @@ export default class ModuleAddCommand extends BaseCommand {
       // Shallow clone to inspect
       await clone(cleanUrl, stagingDir, { depth: 1 });
 
-      // Read module.yaml
+      // Search path handling
       const searchPath = subPath ? path.join(stagingDir, subPath) : stagingDir;
+
+      // 1. Detect Module Name & Dependencies
       const moduleYamlPath = path.join(searchPath, 'module.yaml');
       const moduleYmlPath = path.join(searchPath, 'module.yml');
+      const pkgJsonPath = path.join(searchPath, 'package.json');
 
       let configPath = '';
       if (await fs.pathExists(moduleYamlPath)) configPath = moduleYamlPath;
       else if (await fs.pathExists(moduleYmlPath)) configPath = moduleYmlPath;
-      else {
-        throw new Error(`No module.yaml found in ${cleanUrl}${subPath ? '//' + subPath : ''}`);
+
+      // Try to get name from module.yaml/yml
+      if (configPath) {
+        const configContent = await fs.readFile(configPath, 'utf8');
+        const config = YAML.parse(configContent);
+        if (config.name) moduleName = config.name;
+        dependencies = config.dependencies || [];
       }
 
-      const configContent = await fs.readFile(configPath, 'utf8');
-      const config = YAML.parse(configContent);
+      // If no name yet, try package.json
+      if (!moduleName && (await fs.pathExists(pkgJsonPath))) {
+        try {
+          const pkg = await fs.readJson(pkgJsonPath);
+          if (pkg.name) {
+            // Handle scoped packages @modules/name -> name
+            moduleName = pkg.name.startsWith('@modules/') ? pkg.name.split('/')[1] : pkg.name;
+          }
+        } catch {
+          /* ignore */
+        }
+      }
 
-      if (!config.name) {
-        throw new Error(`Module at ${url} is missing 'name' in module.yaml`);
+      // Fallback to git repo name if still no name
+      if (!moduleName) {
+        moduleName = path.basename(cleanUrl, '.git');
       }
-      moduleName = config.name;
-      dependencies = config.dependencies || [];
 
-      // Normalize dependencies to array if object (though spec says list of strings, defensiveness is good)
+      // 2. Detect Module Type
+      // Frontend indicators: ui.yaml, or specifically typed in module.config.mjs (harder to parse statically), or package.json dependencies like 'react'/'astro' (maybe too broad).
+      // Backend indicators: models.yaml, api.yaml, access.yaml.
+
+      const hasUiYaml = await fs.pathExists(path.join(searchPath, 'ui.yaml'));
+      const hasModelsYaml = await fs.pathExists(path.join(searchPath, 'models.yaml'));
+      const hasApiYaml = await fs.pathExists(path.join(searchPath, 'api.yaml'));
+
+      if (hasUiYaml) {
+        moduleType = 'frontend';
+      } else if (hasModelsYaml || hasApiYaml) {
+        moduleType = 'backend';
+      } else {
+        // Fallback: Check checking package.json for "auth-astro" which is common in both, but maybe "react" or "vue" for frontend?
+        // Let's assume Backend default if ambiguous for now, or check for specific folder structure?
+        // Let's look for `src/components` vs `src/services`.
+        if (await fs.pathExists(path.join(searchPath, 'src', 'components'))) {
+          moduleType = 'frontend';
+        } else {
+          moduleType = 'backend';
+        }
+      }
+
+      // Normalize dependencies
       if (dependencies && !Array.isArray(dependencies)) {
         dependencies = Object.keys(dependencies);
       }
@@ -104,39 +145,34 @@ export default class ModuleAddCommand extends BaseCommand {
       await fs.remove(stagingDir);
     }
 
-    // Stage 2: Conflict Detection
-    const targetDir = path.join(projectRoot!, 'modules', moduleName);
-    const relativeTargetDir = path.relative(projectRoot!, targetDir);
+    // Stage 2: Conflict Detection & Path Resolution
+    const modulesBaseDir =
+      moduleType === 'frontend' ? 'apps/frontend/modules' : 'apps/backend/modules';
+    const relativeTargetDir = path.join(modulesBaseDir, moduleName);
+    const targetDir = path.join(projectRoot!, relativeTargetDir);
 
     if (await fs.pathExists(targetDir)) {
       // Check origin
       const existingRemote = await getRemoteUrl(targetDir);
-      // We compare cleanUrl (the repo root).
-      // normalize both
       const normExisting = existingRemote.replace(/\.git$/, '');
       const normNew = cleanUrl.replace(/\.git$/, '');
 
       if (normExisting !== normNew && existingRemote !== '') {
         throw new Error(
-          `Dependency Conflict! Module '${moduleName}' exists but remote '${existingRemote}' does not match '${cleanUrl}'.`,
+          `Dependency Conflict! Module '${moduleName}' exists in ${moduleType} but remote '${existingRemote}' does not match '${cleanUrl}'.`,
         );
       }
 
-      this.info(`Module ${moduleName} already installed.`);
-      // Proceed to recurse, but skip add
+      this.info(`Module ${moduleName} already installed in ${moduleType}.`);
     } else {
       // Stage 3: Submodule Add
-      this.info(`Installing ${moduleName} to ${relativeTargetDir}...`);
-      // We install the ROOT repo.
-      // IMPORTANT: If subPath exists, "Identity is Internal" means we name the folder `moduleName`.
-      // But the CONTENT will be the whole repo.
-      // If the user meant to only have the subdir, we can't do that with submodule add easily without manual git plumbing.
-      // Given instructions, I will proceed with submodule add of root repo to target dir.
+      this.info(`Installing ${moduleName} (${moduleType}) to ${relativeTargetDir}...`);
+      await fs.ensureDir(path.dirname(targetDir)); // Ensure apps/backend/modules exists
       await runCommand(`git submodule add ${cleanUrl} ${relativeTargetDir}`, projectRoot!);
     }
 
     // Update nexical.yaml
-    await this.addToConfig(moduleName);
+    await this.addToConfig(moduleName, moduleType);
 
     // Stage 4: Recurse
     if (dependencies.length > 0) {
@@ -147,12 +183,11 @@ export default class ModuleAddCommand extends BaseCommand {
     }
   }
 
-  private async addToConfig(moduleName: string) {
+  private async addToConfig(moduleName: string, type: 'backend' | 'frontend') {
     const projectRoot = this.projectRoot as string;
     const configPath = path.join(projectRoot, 'nexical.yaml');
 
     if (!(await fs.pathExists(configPath))) {
-      // Not strictly required to exist for all operations, but good to have if we are tracking modules.
       logger.warn('nexical.yaml not found, skipping module list update.');
       return;
     }
@@ -161,12 +196,20 @@ export default class ModuleAddCommand extends BaseCommand {
       const content = await fs.readFile(configPath, 'utf8');
       const config = YAML.parse(content) || {};
 
-      if (!config.modules) config.modules = [];
+      if (!config.modules) config.modules = {};
+
+      // Migration: If modules is array, convert to object
+      if (Array.isArray(config.modules)) {
+        const oldModules = config.modules;
+        config.modules = { backend: oldModules, frontend: [] }; // Assume old were backend? Or just move them to backend for safety.
+      }
+
+      if (!config.modules[type]) config.modules[type] = [];
 
-      if (!config.modules.includes(moduleName)) {
-        config.modules.push(moduleName);
+      if (!config.modules[type].includes(moduleName)) {
+        config.modules[type].push(moduleName);
         await fs.writeFile(configPath, YAML.stringify(config));
-        logger.debug(`Added ${moduleName} to nexical.yaml modules list.`);
+        logger.debug(`Added ${moduleName} to nexical.yaml modules.${type} list.`);
       }
     } catch (e: unknown) {
       if (e instanceof Error) {

package/src/commands/module/list.ts

@@ -1,8 +1,15 @@
-import { BaseCommand, logger } from '@nexical/cli-core';
+import { BaseCommand } from '@nexical/cli-core';
 import fs from 'fs-extra';
 import path from 'path';
 import YAML from 'yaml';
 
+interface ModuleInfo {
+  name: string;
+  version: string;
+  description: string;
+  type: 'backend' | 'frontend' | 'legacy';
+}
+
 export default class ModuleListCommand extends BaseCommand {
   static usage = 'module list';
   static description = 'List installed modules.';
@@ -10,71 +17,87 @@ export default class ModuleListCommand extends BaseCommand {
 
   async run() {
     const projectRoot = this.projectRoot as string;
-    const modulesDir = path.resolve(projectRoot, 'modules');
-    logger.debug(`Scanning for modules in: ${modulesDir}`);
 
-    if (!(await fs.pathExists(modulesDir))) {
-      this.info('No modules installed (modules directory missing).');
-      return;
-    }
+    // Define locations to scan
+    const builtInLocations = [
+      { type: 'backend', path: path.join(projectRoot, 'apps/backend/modules') },
+      { type: 'frontend', path: path.join(projectRoot, 'apps/frontend/modules') },
+      // Check legacy `modules` folder just in case?
+      { type: 'legacy', path: path.join(projectRoot, 'modules') },
+    ];
 
-    try {
-      const modules = await fs.readdir(modulesDir);
-      const validModules: { name: string; version: string; description: string }[] = [];
-
-      for (const moduleName of modules) {
-        const modulePath = path.join(modulesDir, moduleName);
-        if ((await fs.stat(modulePath)).isDirectory()) {
-          let version = 'unknown';
-          let description = '';
-
-          const pkgJsonPath = path.join(modulePath, 'package.json');
-          const moduleYamlPath = path.join(modulePath, 'module.yaml');
-          const moduleYmlPath = path.join(modulePath, 'module.yml');
-
-          let pkg: Record<string, unknown> = {};
-          let modConfig: Record<string, unknown> = {};
-
-          if (await fs.pathExists(pkgJsonPath)) {
-            try {
-              pkg = await fs.readJson(pkgJsonPath);
-            } catch {
-              /* ignore */
-            }
-          }
+    const allModules: ModuleInfo[] = [];
 
-          if ((await fs.pathExists(moduleYamlPath)) || (await fs.pathExists(moduleYmlPath))) {
-            try {
-              const configPath = (await fs.pathExists(moduleYamlPath))
-                ? moduleYamlPath
-                : moduleYmlPath;
-              const content = await fs.readFile(configPath, 'utf8');
-              modConfig = YAML.parse(content) || {};
-            } catch {
-              /* ignore */
-            }
-          }
+    for (const loc of builtInLocations) {
+      if (await fs.pathExists(loc.path)) {
+        const modules = await fs.readdir(loc.path);
 
-          version = (pkg.version as string) || (modConfig.version as string) || 'unknown';
-          description = (pkg.description as string) || (modConfig.description as string) || '';
-          // Optionally use display name from module.yaml if present, but strictly list is usually dir name.
-          // Let's stick to dir name for "name" column, but description from module.yaml is good.
-          validModules.push({ name: moduleName, version, description });
+        for (const moduleName of modules) {
+          const modulePath = path.join(loc.path, moduleName);
+          if ((await fs.stat(modulePath)).isDirectory()) {
+            const info = await this.getModuleInfo(
+              modulePath,
+              moduleName,
+              loc.type as 'backend' | 'frontend' | 'legacy',
+            );
+            allModules.push(info);
+          }
         }
       }
+    }
+
+    if (allModules.length === 0) {
+      this.info('No modules installed.');
+    } else {
+      // Sort by type then name
+      allModules.sort((a, b) => {
+        if (a.type !== b.type) return a.type.localeCompare(b.type);
+        return a.name.localeCompare(b.name);
+      });
+      // eslint-disable-next-line no-console
+      console.table(allModules);
+    }
+  }
+
+  private async getModuleInfo(
+    modulePath: string,
+    dirName: string,
+    type: 'backend' | 'frontend' | 'legacy',
+  ): Promise<ModuleInfo> {
+    let version = 'unknown';
+    let description = '';
+
+    const pkgJsonPath = path.join(modulePath, 'package.json');
+    const moduleYamlPath = path.join(modulePath, 'module.yaml');
+    const moduleYmlPath = path.join(modulePath, 'module.yml');
 
-      if (validModules.length === 0) {
-        this.info('No modules installed.');
-      } else {
-        // eslint-disable-next-line no-console
-        console.table(validModules);
+    let pkg: Record<string, unknown> = {};
+    let modConfig: Record<string, unknown> = {};
+
+    if (await fs.pathExists(pkgJsonPath)) {
+      try {
+        pkg = (await fs.readJson(pkgJsonPath)) || {};
+      } catch {
+        /* ignore */
       }
-    } catch (error: unknown) {
-      if (error instanceof Error) {
-        this.error(`Failed to list modules: ${error.message}`);
-      } else {
-        this.error(`Failed to list modules: ${String(error)}`);
+    }
+
+    if ((await fs.pathExists(moduleYamlPath)) || (await fs.pathExists(moduleYmlPath))) {
+      try {
+        const configPath = (await fs.pathExists(moduleYamlPath)) ? moduleYamlPath : moduleYmlPath;
+        const content = await fs.readFile(configPath, 'utf8');
+        modConfig = YAML.parse(content) || {};
+      } catch {
+        /* ignore */
       }
     }
+
+    version = (pkg.version as string) || (modConfig.version as string) || 'unknown';
+    description = (pkg.description as string) || (modConfig.description as string) || '';
+
+    // Use config name if available, else dirName
+    const name = (modConfig.name as string) || dirName;
+
+    return { name, version, description, type };
   }
 }

package/src/commands/module/remove.ts

@@ -16,27 +16,44 @@ export default class ModuleRemoveCommand extends BaseCommand {
     const projectRoot = this.projectRoot as string;
     const { name } = options;
 
-    const relativePath = `modules/${name}`;
-    const fullPath = path.resolve(projectRoot, relativePath);
-
-    logger.debug('Removing module at:', fullPath);
+    // Check locations
+    const locations = [
+      { type: 'backend', path: `apps/backend/modules/${name}` },
+      { type: 'frontend', path: `apps/frontend/modules/${name}` },
+      { type: 'legacy', path: `modules/${name}` },
+    ];
+
+    let targetLoc: { type: string; path: string } | null = null;
+    let fullPath = '';
+
+    for (const loc of locations) {
+      const absPath = path.resolve(projectRoot, loc.path);
+      if (await fs.pathExists(absPath)) {
+        targetLoc = loc;
+        fullPath = absPath;
+        break;
+      }
+    }
 
-    if (!(await fs.pathExists(fullPath))) {
-      this.error(`Module ${name} not found at ${relativePath}.`);
+    if (!targetLoc) {
+      this.error(`Module ${name} not found in any standard location.`);
       return;
     }
 
-    this.info(`Removing module ${name}...`);
+    const relativePath = targetLoc.path;
+
+    logger.debug('Removing module at:', fullPath);
+    this.info(`Removing module ${name} (${targetLoc.type})...`);
 
     try {
       await runCommand(`git submodule deinit -f ${relativePath}`, projectRoot);
       await runCommand(`git rm -f ${relativePath}`, projectRoot);
 
-      // Clean up .git/modules
-      const gitModulesDir = path.resolve(projectRoot, '.git', 'modules', 'modules', name);
-      if (await fs.pathExists(gitModulesDir)) {
-        await fs.remove(gitModulesDir);
-      }
+      // Clean up .git/modules if needed (git rm often handles this but sometimes leaves stale dirs in .git/modules)
+      // The path in .git/modules depends on how it was added.
+      // Usually .git/modules/apps/backend/modules/name
+      // We'll leave strict git cleanup to git, manually removing can be risky if path structure varies.
+      // But we can check for the directory itself just in case.
 
       this.info('Syncing workspace dependencies...');
       await runCommand('npm install', projectRoot);
@@ -63,8 +80,27 @@ export default class ModuleRemoveCommand extends BaseCommand {
       const content = await fs.readFile(configPath, 'utf8');
       const config = YAML.parse(content) || {};
 
-      if (config.modules && config.modules.includes(moduleName)) {
-        config.modules = config.modules.filter((m: string) => m !== moduleName);
+      let changed = false;
+
+      if (config.modules) {
+        // Check if object
+        if (!Array.isArray(config.modules)) {
+          for (const key of Object.keys(config.modules)) {
+            if (Array.isArray(config.modules[key]) && config.modules[key].includes(moduleName)) {
+              config.modules[key] = config.modules[key].filter((m: string) => m !== moduleName);
+              changed = true;
+            }
+          }
+        } else {
+          // Legacy array
+          if (config.modules.includes(moduleName)) {
+            config.modules = config.modules.filter((m: string) => m !== moduleName);
+            changed = true;
+          }
+        }
+      }
+
+      if (changed) {
         await fs.writeFile(configPath, YAML.stringify(config));
         logger.debug(`Removed ${moduleName} from nexical.yaml modules list.`);
       }

package/src/commands/module/update.ts

@@ -20,17 +20,31 @@ export default class ModuleUpdateCommand extends BaseCommand {
 
     try {
       if (name) {
-        const relativePath = `modules/${name}`;
-        const fullPath = path.resolve(projectRoot, relativePath);
+        // Check locations
+        const locations = [
+          { type: 'backend', path: `apps/backend/modules/${name}` },
+          { type: 'frontend', path: `apps/frontend/modules/${name}` },
+          { type: 'legacy', path: `modules/${name}` },
+        ];
 
-        if (!(await fs.pathExists(fullPath))) {
+        let targetLoc: { type: string; path: string } | null = null;
+
+        for (const loc of locations) {
+          const absPath = path.resolve(projectRoot, loc.path);
+          if (await fs.pathExists(absPath)) {
+            targetLoc = loc;
+            break;
+          }
+        }
+
+        if (!targetLoc) {
           this.error(`Module ${name} not found.`);
           return;
         }
 
+        const relativePath = targetLoc.path;
+
         // Update specific module
-        // We enter the directory and pull? Or generic submodule update?
-        // Generic submodule update --remote src/modules/name
         await runCommand(`git submodule update --remote --merge ${relativePath}`, projectRoot);
       } else {
         // Update all

package/src/commands/run.ts

@@ -38,9 +38,29 @@ export default class RunCommand extends BaseCommand {
     // Handle module:script syntax
     if (script.includes(':')) {
       const [moduleName, name] = script.split(':');
-      execPath = path.resolve(projectRoot, 'modules', moduleName);
       scriptName = name;
 
+      const locations = [
+        { type: 'backend', path: `apps/backend/modules/${moduleName}` },
+        { type: 'frontend', path: `apps/frontend/modules/${moduleName}` },
+        { type: 'legacy', path: `modules/${moduleName}` },
+      ];
+
+      let found = false;
+      for (const loc of locations) {
+        const absPath = path.resolve(projectRoot, loc.path);
+        if (await fs.pathExists(absPath)) {
+          execPath = absPath;
+          found = true;
+          break;
+        }
+      }
+
+      if (!found) {
+        this.error(`Module ${moduleName} not found.`);
+        return;
+      }
+
       logger.debug(`Resolving module script: ${moduleName}:${scriptName} at ${execPath}`);
     } else {
       logger.debug(`Resolving core script: ${scriptName} at ${execPath}`);

package/test/e2e/lifecycle.e2e.test.ts

@@ -122,7 +122,7 @@ if (args[0] === 'build') {
         'module',
         'add',
         moduleDir,
-        'my-test-module', // Explicit name
+        // Name is inferred from module.yaml
       ],
       projectDir,
       { env },
@@ -132,7 +132,8 @@ if (args[0] === 'build') {
       console.error('Module Add Failed:', modResult.stderr || modResult.stdout);
     }
     expect(modResult.exitCode).toBe(0);
-    expect(fs.existsSync(path.join(projectDir, 'modules/my-test-module'))).toBe(true);
+    // Defaults to backend module
+    expect(fs.existsSync(path.join(projectDir, 'apps/backend/modules/my-test-module'))).toBe(true);
 
     // --- STEP 3: BUILD ---
     // Run: nexical run build