@nexical/cli 0.11.8 → 0.11.10

package/test/unit/commands/module/list.test.ts

@@ -1,132 +1,133 @@
-// import { BaseCommand } from '@nexical/cli-core';
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
 import ModuleListCommand from '../../../../src/commands/module/list.js';
 import fs from 'fs-extra';
 
-vi.mock('@nexical/cli-core', async (importOriginal) => {
-  const mod = await importOriginal<typeof import('@nexical/cli-core')>();
-  return {
-    ...mod,
-    logger: {
-      ...mod.logger,
-      success: vi.fn(),
-      info: vi.fn(),
-      debug: vi.fn(),
-      error: vi.fn(),
-      warn: vi.fn(),
-    },
-    runCommand: vi.fn(),
-  };
-});
 vi.mock('fs-extra');
 
 describe('ModuleListCommand', () => {
   let command: ModuleListCommand;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  let consoleTableSpy: any;
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    command = new ModuleListCommand({}, { rootDir: '/mock/root' });
-    consoleTableSpy = vi.spyOn(console, 'table').mockImplementation(() => {});
-    vi.spyOn(command, 'error').mockImplementation(() => {});
-    vi.spyOn(command, 'success').mockImplementation(() => {});
+  const projectRoot = '/mock/project';
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    command = new ModuleListCommand({} as any, { rootDir: projectRoot });
+    (command as any).projectRoot = projectRoot;
+    vi.spyOn(console, 'table').mockImplementation(() => {});
     vi.spyOn(command, 'info').mockImplementation(() => {});
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    vi.mocked(fs.pathExists).mockImplementation(async (p: any) => {
-      if (p.includes('app.yml') || p.includes('nexical.yml')) return true;
-      return true;
+
+    // Default mocks for info gathering
+    (fs.readJson as unknown as { mockResolvedValue: any }).mockResolvedValue({});
+    (fs.readFile as unknown as { mockResolvedValue: any }).mockResolvedValue('');
+    (fs.pathExists as unknown as { mockResolvedValue: any }).mockResolvedValue(false);
+    (fs.stat as unknown as { mockResolvedValue: any }).mockResolvedValue({
+      isDirectory: () => true,
     });
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
-    await command.init();
   });
 
-  afterEach(() => {
-    vi.resetAllMocks();
-  });
+  it('should list modules from both backend and frontend', async () => {
+    (fs.pathExists as unknown as { mockImplementation: any }).mockImplementation(
+      (p: string) => true,
+    );
+    (fs.readdir as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      if (p.includes('backend')) return ['mod-b'];
+      if (p.includes('frontend')) return ['mod-f'];
+      return [];
+    });
+
+    await command.run();
 
-  it('should have correct static properties', () => {
-    expect(ModuleListCommand.usage).toContain('module list');
-    expect(ModuleListCommand.description).toBeDefined();
-    expect(ModuleListCommand.requiresProject).toBe(true);
+    // eslint-disable-next-line no-console
+    expect(console.table).toHaveBeenCalledWith([
+      { name: 'mod-b', type: 'backend', version: 'unknown', description: '' },
+      { name: 'mod-f', type: 'frontend', version: 'unknown', description: '' },
+    ]);
   });
 
-  it('should error if project root is missing', async () => {
-    command = new ModuleListCommand({}, { rootDir: undefined });
-    vi.spyOn(command, 'init').mockImplementation(async () => {});
-    vi.spyOn(command, 'error').mockImplementation(() => {});
+  it('should handle empty module directories', async () => {
+    (fs.pathExists as unknown as { mockReturnValue: any }).mockReturnValue(true);
+    (fs.readdir as unknown as { mockResolvedValue: any }).mockResolvedValue([]);
 
-    await command.runInit({});
-    expect(command.error).toHaveBeenCalledWith(
-      expect.stringContaining('requires to be run within an app project'),
-      1,
-    );
+    await command.run();
+    expect(command.info).toHaveBeenCalledWith('No modules installed.');
   });
 
-  it('should handle missing modules directory', async () => {
-    vi.mocked(fs.pathExists).mockImplementation(async () => false);
+  it('should sort modules by name', async () => {
+    (fs.pathExists as unknown as { mockReturnValue: any }).mockReturnValue(true);
+    (fs.readdir as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      if (p.includes('backend')) return ['z-mod', 'a-mod'];
+      return [];
+    });
+
     await command.run();
-    expect(command.info).toHaveBeenCalledWith(expect.stringContaining('No modules installed'));
+
+    // eslint-disable-next-line no-console
+    expect(console.table).toHaveBeenCalledWith([
+      { name: 'a-mod', type: 'backend', version: 'unknown', description: '' },
+      { name: 'z-mod', type: 'backend', version: 'unknown', description: '' },
+    ]);
   });
 
-  it('should list modules with details', async () => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    vi.mocked(fs.readdir).mockResolvedValue(['mod1', 'file.txt', 'mod2', 'mod3', 'mod4'] as any);
-    // Mock directory check: mod1=dir, file.txt=file, mod2=dir, mod3=dir
-    vi.mocked(fs.stat).mockImplementation(
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      async (p: any) =>
-        ({
-          isDirectory: () => !p.includes('file.txt'),
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        }) as any,
-    );
+  it('should handle missing directories', async () => {
+    (fs.pathExists as any).mockReturnValue(false);
+    await command.run();
+    expect(command.info).toHaveBeenCalledWith('No modules installed.');
+  });
 
-    // Mock package.json existence: mod1=yes, mod2=no, mod3=yes
-    // Also ensure modules directory itself exists!
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    vi.mocked(fs.pathExists).mockImplementation(async (p: any) => {
-      if (p.includes('app.yml') || p.includes('nexical.yml')) return true;
-      if (p.endsWith('/modules')) return true;
-      return p.includes('package.json') && !p.includes('mod2');
-    });
+  it('should handle one directory missing and one empty', async () => {
+    (fs.pathExists as any).mockImplementation((p: string) => p.includes('backend'));
+    (fs.readdir as unknown as { mockResolvedValue: any }).mockResolvedValue([]);
+    await command.run();
+    expect(command.info).toHaveBeenCalledWith('No modules installed.');
+  });
 
-    // Mock reading json: mod1=valid, mod3=invalid, mod4=empty
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    vi.mocked(fs.readJson).mockImplementation(async (p: any) => {
-      if (p.includes('mod3')) throw new Error('Invalid JSON');
-      if (p.includes('mod4')) return {}; // No version/desc
-      return { version: '1.0.0', description: 'Desc' };
+  it('should handle backend empty and frontend not empty', async () => {
+    (fs.pathExists as unknown as { mockReturnValue: any }).mockReturnValue(true);
+    (fs.readdir as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      if (p.includes('backend')) return [];
+      if (p.includes('frontend')) return ['front-mod'];
+      return [];
     });
-
     await command.run();
-
-    // mod1: listed with version
-    // file.txt: ignored
-    // mod2: listed with unknown version (dir exists, no pkg.json)
-    // mod3: listed with unknown version (invalid pkg.json)
-    // mod4: listed with unknown/empty (fallback logic)
-    expect(consoleTableSpy).toHaveBeenCalledWith(
-      expect.arrayContaining([
-        { name: 'mod1', version: '1.0.0', description: 'Desc' },
-        { name: 'mod2', version: 'unknown', description: '' },
-        { name: 'mod3', version: 'unknown', description: '' },
-        { name: 'mod4', version: 'unknown', description: '' },
-      ]),
-    );
+    // eslint-disable-next-line no-console
+    expect(console.table).toHaveBeenCalledWith([
+      { name: 'front-mod', type: 'frontend', version: 'unknown', description: '' },
+    ]);
   });
 
-  it('should handle empty modules directory', async () => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    vi.mocked(fs.readdir).mockResolvedValue([] as any);
+  it('should handle non-directory entries', async () => {
+    (fs.pathExists as unknown as { mockReturnValue: any }).mockReturnValue(true);
+    (fs.readdir as any).mockResolvedValue(['file.txt']);
+    (fs.stat as any).mockResolvedValue({ isDirectory: () => false });
+
     await command.run();
     expect(command.info).toHaveBeenCalledWith('No modules installed.');
   });
 
-  it('should handle failure during list', async () => {
-    vi.mocked(fs.readdir).mockRejectedValue(new Error('FS Error'));
+  it('should handle empty config and package.json', async () => {
+    (fs.pathExists as unknown as { mockReturnValue: any }).mockReturnValue(true);
+
+    // Config files exist check returns true, but readJson/readFile fail or return null
+    (fs.pathExists as unknown as { mockImplementation: any }).mockImplementation(
+      (p: string) => true,
+    );
+
+    // Only return module for backend path to avoid duplicates in test output
+    (fs.readdir as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      if (p.includes('apps/backend/modules')) return ['mod-a'];
+      return [];
+    });
+
+    (fs.stat as unknown as { mockResolvedValue: any }).mockResolvedValue({
+      isDirectory: () => true,
+    });
+    (fs.readJson as any).mockResolvedValue(null);
+    (fs.readFile as unknown as { mockResolvedValue: any }).mockResolvedValue(''); // Empty string -> YAML.parse returns null/undefined
+
     await command.run();
-    expect(command.error).toHaveBeenCalledWith(expect.stringContaining('Failed to list modules'));
+
+    // eslint-disable-next-line no-console
+    expect(console.table).toHaveBeenCalledWith([
+      { name: 'mod-a', type: 'backend', version: 'unknown', description: '' },
+    ]);
   });
 });

package/test/unit/commands/module/remove.test.ts

@@ -1,96 +1,181 @@
-import { runCommand } from '@nexical/cli-core';
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import ModuleRemoveCommand from '../../../../src/commands/module/remove.js';
 import fs from 'fs-extra';
+import * as cliCore from '@nexical/cli-core';
 
+// Mocks
+vi.mock('fs-extra');
 vi.mock('@nexical/cli-core', async (importOriginal) => {
   const mod = await importOriginal<typeof import('@nexical/cli-core')>();
   return {
     ...mod,
-    logger: {
-      ...mod.logger,
-      success: vi.fn(),
-      info: vi.fn(),
-      debug: vi.fn(),
-      error: vi.fn(),
-      warn: vi.fn(),
-    },
     runCommand: vi.fn(),
   };
 });
-vi.mock('fs-extra');
 
 describe('ModuleRemoveCommand', () => {
   let command: ModuleRemoveCommand;
+  const projectRoot = '/mock/project/root';
 
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    command = new ModuleRemoveCommand({}, { rootDir: '/mock/root' });
-    vi.spyOn(command, 'error').mockImplementation(() => {});
-    vi.spyOn(command, 'success').mockImplementation(() => {});
+  beforeEach(() => {
+    vi.resetAllMocks();
+
+    // Mock logger
+    vi.spyOn(cliCore.logger, 'debug').mockImplementation(() => {});
+    vi.spyOn(cliCore.logger, 'warn').mockImplementation(() => {});
+    vi.spyOn(cliCore.logger, 'info').mockImplementation(() => {});
+
+    command = new ModuleRemoveCommand({} as unknown as any, { rootDir: projectRoot });
+    (command as unknown as { projectRoot: string }).projectRoot = projectRoot;
+
+    // Explicitly spy on command methods
     vi.spyOn(command, 'info').mockImplementation(() => {});
-    vi.mocked(fs.pathExists).mockImplementation(async (p: string) => {
-      if (p.includes('app.yml') || p.includes('nexical.yml')) return true;
-      return true;
-    });
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
-    await command.init();
+    vi.spyOn(command, 'success').mockImplementation(() => {});
+    vi.spyOn(command, 'error').mockImplementation(() => {});
+    vi.spyOn(command, 'warn').mockImplementation(() => {});
+
+    (cliCore.runCommand as unknown as { mockResolvedValue: any }).mockResolvedValue(undefined);
   });
 
   afterEach(() => {
-    vi.resetAllMocks();
+    vi.restoreAllMocks();
   });
 
-  it('should have correct static properties', () => {
-    expect(ModuleRemoveCommand.usage).toContain('module remove');
-    expect(ModuleRemoveCommand.description).toBeDefined();
-    expect(ModuleRemoveCommand.requiresProject).toBe(true);
-    expect(ModuleRemoveCommand.args).toBeDefined();
+  it('should identify and remove a backend module', async () => {
+    // Setup: Simulate module exists in backend
+    (fs.pathExists as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      const pStr = p.toString();
+      if (pStr.includes('apps/backend/modules/test-mod')) return true;
+      if (pStr.includes('nexical.yaml')) return true;
+      return false;
+    });
+    (fs.readFile as unknown as { mockResolvedValue: any }).mockResolvedValue(
+      'modules:\n  backend:\n    - test-mod',
+    );
+    (fs.writeFile as unknown as { mockResolvedValue: any }).mockResolvedValue(undefined);
+
+    await command.run({ name: 'test-mod' });
+
+    // Verify git commands
+    expect(cliCore.runCommand).toHaveBeenCalledWith(
+      expect.stringContaining('git submodule deinit -f apps/backend/modules/test-mod'),
+      projectRoot,
+    );
+    expect(cliCore.runCommand).toHaveBeenCalledWith(
+      expect.stringContaining('git rm -f apps/backend/modules/test-mod'),
+      projectRoot,
+    );
+
+    // Verify config update
+    expect(fs.writeFile).toHaveBeenCalledWith(
+      expect.stringContaining('nexical.yaml'),
+      expect.not.stringContaining('test-mod'),
+    );
   });
 
-  it('should error if project root is missing', async () => {
-    command = new ModuleRemoveCommand({}, { rootDir: undefined });
-    vi.spyOn(command, 'init').mockImplementation(async () => {});
-    vi.spyOn(command, 'error').mockImplementation(() => {});
+  it('should error if module not found', async () => {
+    (fs.pathExists as unknown as { mockResolvedValue: any }).mockResolvedValue(false);
 
-    await command.runInit({ name: 'mod' });
-    expect(command.error).toHaveBeenCalledWith(
-      expect.stringContaining('requires to be run within an app project'),
-      1,
+    await command.run({ name: 'missing-mod' });
+
+    expect(command.error).toHaveBeenCalledWith(expect.stringContaining('not found'));
+    expect(cliCore.runCommand).not.toHaveBeenCalled();
+  });
+
+  it('should remove from legacy modules array', async () => {
+    (fs.pathExists as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      const pStr = p.toString();
+      if (pStr.includes('apps/backend/modules/legacy-mod')) return true;
+      if (pStr.includes('nexical.yaml')) return true;
+      return false;
+    });
+    (fs.readFile as unknown as { mockResolvedValue: any }).mockResolvedValue(
+      'modules:\n  - other-mod\n  - legacy-mod',
+    );
+
+    await command.run({ name: 'legacy-mod' });
+
+    expect(fs.writeFile).toHaveBeenCalledWith(
+      expect.stringContaining('nexical.yaml'),
+      expect.not.stringContaining('legacy-mod'),
     );
   });
 
-  it('should remove submodule and sync', async () => {
-    await command.run({ name: 'mod' });
+  it('should handle error during nexical.yaml update', async () => {
+    (fs.pathExists as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      const pStr = p.toString();
+      if (pStr.includes('apps/backend/modules/test-mod')) return true;
+      if (pStr.includes('nexical.yaml')) return true;
+      return false;
+    });
+    (fs.readFile as unknown as { mockResolvedValue: any }).mockResolvedValue(
+      'modules:\n  backend:\n    - test-mod',
+    );
+    (fs.writeFile as unknown as { mockRejectedValue: any }).mockRejectedValue(
+      new Error('Write fail'),
+    );
 
-    expect(runCommand).toHaveBeenCalledWith(
-      expect.stringContaining('git submodule deinit'),
-      '/mock/root',
+    await command.run({ name: 'test-mod' });
+    expect(cliCore.logger.warn).toHaveBeenCalledWith(
+      expect.stringContaining('Failed to update nexical.yaml: Write fail'),
     );
-    expect(runCommand).toHaveBeenCalledWith(expect.stringContaining('git rm'), '/mock/root');
-    expect(fs.remove).toHaveBeenCalledWith(expect.stringContaining('.git/modules'));
-    expect(runCommand).toHaveBeenCalledWith('npm install', '/mock/root');
   });
 
-  it('should error if module not found', async () => {
-    vi.mocked(fs.pathExists).mockImplementation(async () => false);
-    await command.run({ name: 'missing' });
-    expect(command.error).toHaveBeenCalledWith(expect.stringContaining('not found'));
+  it('should handle non-Error exception during nexical.yaml update', async () => {
+    (fs.pathExists as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      const pStr = p.toString();
+      if (pStr.includes('apps/backend/modules/test-mod')) return true;
+      if (pStr.includes('nexical.yaml')) return true;
+      return false;
+    });
+    (fs.readFile as unknown as { mockResolvedValue: any }).mockResolvedValue(
+      'modules:\n  backend:\n    - test-mod',
+    );
+    (fs.writeFile as unknown as { mockRejectedValue: any }).mockRejectedValue('String fail');
+
+    await command.run({ name: 'test-mod' });
+    expect(cliCore.logger.warn).toHaveBeenCalledWith(
+      expect.stringContaining('Failed to update nexical.yaml: String fail'),
+    );
   });
 
-  it('should handle failure during remove', async () => {
-    vi.mocked(runCommand).mockRejectedValue(new Error('Git remove failed'));
-    await command.run({ name: 'mod' });
-    expect(command.error).toHaveBeenCalledWith(expect.stringContaining('Failed to remove module'));
+  it('should handle error during run method', async () => {
+    (fs.pathExists as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      if (p.includes('apps/backend/modules/fail-mod')) return true;
+      return false;
+    });
+    (cliCore.runCommand as unknown as { mockRejectedValue: any }).mockRejectedValue(
+      new Error('Git fail'),
+    );
+
+    await command.run({ name: 'fail-mod' });
+    expect(command.error).toHaveBeenCalledWith(
+      expect.stringContaining('Failed to remove module: Git fail'),
+    );
   });
 
-  it('should skip .git/modules cleanup if not found', async () => {
-    vi.mocked(fs.pathExists).mockImplementation(async (p: string) => {
-      if (p.includes('.git/modules')) return false;
-      return true;
+  it('should handle non-Error exception during run method', async () => {
+    (fs.pathExists as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      if (p.includes('apps/backend/modules/fail-mod')) return true;
+      return false;
     });
-    await command.run({ name: 'mod' });
-    expect(fs.remove).not.toHaveBeenCalledWith(expect.stringContaining('.git/modules'));
+    (cliCore.runCommand as unknown as { mockRejectedValue: any }).mockRejectedValue('String error');
+
+    await command.run({ name: 'fail-mod' });
+    expect(command.error).toHaveBeenCalledWith(
+      expect.stringContaining('Failed to remove module: String error'),
+    );
+  });
+  it('should do nothing if nexical.yaml is missing', async () => {
+    (fs.pathExists as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      if (p.includes('apps/backend/modules/test-mod')) return true;
+      if (p.includes('nexical.yaml')) return false;
+      return false;
+    });
+
+    await command.run({ name: 'test-mod' });
+    // Should return early and not try to read config
+    expect(fs.readFile).not.toHaveBeenCalled();
+    expect(command.success).toHaveBeenCalledWith(expect.stringContaining('removed successfully'));
   });
 });

package/test/unit/commands/module/update.test.ts

@@ -1,95 +1,78 @@
-import { runCommand } from '@nexical/cli-core';
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import ModuleUpdateCommand from '../../../../src/commands/module/update.js';
 import fs from 'fs-extra';
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import { runCommand, logger } from '@nexical/cli-core';
 
-vi.mock('@nexical/cli-core', async (importOriginal) => {
-  const mod = await importOriginal<typeof import('@nexical/cli-core')>();
+// Mocks
+vi.mock('fs-extra');
+vi.mock('@nexical/cli-core', async () => {
   return {
-    ...mod,
-    logger: {
-      ...mod.logger,
-      success: vi.fn(),
-      info: vi.fn(),
-      debug: vi.fn(),
-      error: vi.fn(),
-      warn: vi.fn(),
+    BaseCommand: class {
+      projectRoot = '/mock/project/root';
+      info = vi.fn();
+      success = vi.fn();
+      error = vi.fn();
     },
+    logger: { debug: vi.fn(), warn: vi.fn() },
     runCommand: vi.fn(),
   };
 });
-vi.mock('fs-extra');
 
 describe('ModuleUpdateCommand', () => {
   let command: ModuleUpdateCommand;
 
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    command = new ModuleUpdateCommand({}, { rootDir: '/mock/root' });
-    vi.spyOn(command, 'error').mockImplementation(() => {});
-    vi.spyOn(command, 'success').mockImplementation(() => {});
-    vi.spyOn(command, 'info').mockImplementation(() => {});
-    vi.mocked(fs.pathExists).mockImplementation(async (p: string) => {
-      if (p.includes('app.yml') || p.includes('nexical.yml')) return true;
-      return true;
-    });
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
-    await command.init();
-  });
-
-  afterEach(() => {
+  beforeEach(() => {
     vi.resetAllMocks();
+    command = new ModuleUpdateCommand({} as unknown as any, {} as unknown as any);
+    (runCommand as unknown as { mockResolvedValue: any }).mockResolvedValue(undefined);
   });
 
-  it('should have correct static properties', () => {
-    expect(ModuleUpdateCommand.usage).toContain('module update');
-    expect(ModuleUpdateCommand.description).toBeDefined();
-    expect(ModuleUpdateCommand.requiresProject).toBe(true);
-    expect(ModuleUpdateCommand.args).toBeDefined();
-  });
-
-  it('should error if project root is missing', async () => {
-    command = new ModuleUpdateCommand({}, { rootDir: undefined });
-    vi.spyOn(command, 'init').mockImplementation(async () => {});
-    vi.spyOn(command, 'error').mockImplementation(() => {});
-
-    await command.runInit({});
-    expect(command.error).toHaveBeenCalledWith(
-      expect.stringContaining('requires to be run within an app project'),
-      1,
-    );
+  afterEach(() => {
+    vi.clearAllMocks();
   });
 
   it('should update all modules if no name provided', async () => {
     await command.run({});
+
     expect(runCommand).toHaveBeenCalledWith(
-      expect.stringContaining('git submodule update --remote'),
-      '/mock/root',
+      'git submodule update --remote --merge',
+      expect.any(String),
     );
-    expect(runCommand).toHaveBeenCalledWith('npm install', '/mock/root');
   });
 
-  it('should update specific module', async () => {
-    await command.run({ name: 'mod' });
+  it('should update specific module if name provided', async () => {
+    (fs.pathExists as unknown as { mockImplementation: any }).mockImplementation((p: string) => {
+      return p.includes('apps/frontend/modules/ui-mod');
+    });
+
+    await command.run({ name: 'ui-mod' });
+
     expect(runCommand).toHaveBeenCalledWith(
-      expect.stringContaining('git submodule update --remote --merge modules/mod'),
-      '/mock/root',
+      expect.stringContaining('git submodule update --remote --merge apps/frontend/modules/ui-mod'),
+      expect.any(String),
     );
   });
 
-  it('should handle failure during update', async () => {
-    vi.mocked(runCommand).mockRejectedValue(new Error('Update failed'));
+  it('should error if specific module not found', async () => {
+    (fs.pathExists as unknown as { mockResolvedValue: any }).mockResolvedValue(false);
+    await command.run({ name: 'missing-mod' });
+    expect(command.error).toHaveBeenCalledWith('Module missing-mod not found.');
+  });
+
+  it('should handle error during update', async () => {
+    (runCommand as unknown as { mockRejectedValue: any }).mockRejectedValue(new Error('Git fail'));
     await command.run({});
-    expect(command.error).toHaveBeenCalledWith(expect.stringContaining('Failed to update'));
+    expect(command.error).toHaveBeenCalledWith(
+      expect.stringContaining('Failed to update modules: Git fail'),
+    );
   });
 
-  it('should error if module to update not found', async () => {
-    vi.mocked(fs.pathExists).mockImplementation(async (p) => {
-      // console.log('UpdateTest: pathExists check:', p);
-      return false;
-    });
-    await command.run({ name: 'missing-mod' });
-    expect(command.error).toHaveBeenCalledWith('Module missing-mod not found.');
+  it('should handle non-Error exception during update', async () => {
+    (runCommand as unknown as { mockRejectedValue: any }).mockRejectedValue('String error');
+    await command.run({});
+    expect(command.error).toHaveBeenCalledWith(
+      expect.stringContaining('Failed to update modules: String error'),
+    );
   });
 });

package/test/unit/commands/run.test.ts

@@ -260,7 +260,7 @@ describe('RunCommand', () => {
   it('should fall back to default behavior if script not found in module', async () => {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     vi.mocked(fs.pathExists).mockImplementation(async (p: any) => {
-      return p.includes('src/modules/mymod') || p.includes('package.json');
+      return p.includes('apps/backend/modules/mymod') || p.includes('package.json');
     });
     vi.mocked(fs.readJson).mockResolvedValue({
       name: 'mymod',
@@ -300,5 +300,20 @@ describe('RunCommand', () => {
     expect(command.error).toHaveBeenCalledWith(
       expect.stringContaining('does not exist in Nexical core'),
     );
+    expect(command.error).toHaveBeenCalledWith(
+      expect.stringContaining('does not exist in Nexical core'),
+    );
+  });
+
+  it('should handle non-Error exception in package.json read', async () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(fs.pathExists).mockImplementation(async (p: any) => p.includes('package.json'));
+    vi.mocked(fs.readJson).mockRejectedValue('String error');
+
+    await command.run({ script: 'test', args: [] });
+
+    expect(command.error).toHaveBeenCalledWith(
+      expect.stringContaining('Failed to read package.json at /mock/root: String error'),
+    );
   });
 });