@nexical/cli 0.10.0 → 0.11.1

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

@@ -1,115 +1,132 @@
-import { BaseCommand, logger } from '@nexical/cli-core';
+// import { BaseCommand } from '@nexical/cli-core';
 import { describe, it, expect, vi, beforeEach, afterEach } 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(),
-    };
+  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;
-    let consoleTableSpy: any;
+  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(() => { });
-        vi.spyOn(command, 'info').mockImplementation(() => { });
-        vi.mocked(fs.pathExists).mockImplementation(async (p: any) => {
-            if (p.includes('app.yml') || p.includes('nexical.yml')) return true;
-            return true;
-        });
-        vi.spyOn(process, 'exit').mockImplementation((() => { }) as any);
-        await command.init();
+  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(() => {});
+    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;
     });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+    await command.init();
+  });
 
-    afterEach(() => {
-        vi.resetAllMocks();
-    });
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
 
-    it('should have correct static properties', () => {
-        expect(ModuleListCommand.usage).toContain('module list');
-        expect(ModuleListCommand.description).toBeDefined();
-        expect(ModuleListCommand.requiresProject).toBe(true);
-    });
+  it('should have correct static properties', () => {
+    expect(ModuleListCommand.usage).toContain('module list');
+    expect(ModuleListCommand.description).toBeDefined();
+    expect(ModuleListCommand.requiresProject).toBe(true);
+  });
 
-    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 error if project root is missing', async () => {
+    command = new ModuleListCommand({}, { 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);
-    });
+    await command.runInit({});
+    expect(command.error).toHaveBeenCalledWith(
+      expect.stringContaining('requires to be run within an app project'),
+      1,
+    );
+  });
 
-    it('should handle missing modules directory', async () => {
-        vi.mocked(fs.pathExists).mockImplementation(async () => false);
-        await command.run();
-        expect(command.info).toHaveBeenCalledWith(expect.stringContaining('No modules installed'));
-    });
+  it('should handle missing modules directory', async () => {
+    vi.mocked(fs.pathExists).mockImplementation(async () => false);
+    await command.run();
+    expect(command.info).toHaveBeenCalledWith(expect.stringContaining('No modules installed'));
+  });
 
-    it('should list modules with details', async () => {
-        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(async (p: any) => ({
-            isDirectory: () => !p.includes('file.txt')
-        } as any));
+  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,
+    );
 
-        // Mock package.json existence: mod1=yes, mod2=no, mod3=yes
-        // Also ensure modules directory itself exists!
-        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');
-        });
+    // 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');
+    });
 
-        // Mock reading json: mod1=valid, mod3=invalid, mod4=empty
-        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' };
-        });
+    // 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' };
+    });
 
-        await command.run();
+    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: '' }
-        ]));
-    });
+    // 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: '' },
+      ]),
+    );
+  });
 
-    it('should handle empty modules directory', async () => {
-        vi.mocked(fs.readdir).mockResolvedValue([] as any);
-        await command.run();
-        expect(command.info).toHaveBeenCalledWith('No modules installed.');
-    });
+  it('should handle empty modules directory', async () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(fs.readdir).mockResolvedValue([] as any);
+    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'));
-        await command.run();
-        expect(command.error).toHaveBeenCalledWith(expect.stringContaining('Failed to list modules'));
-    });
+  it('should handle failure during list', async () => {
+    vi.mocked(fs.readdir).mockRejectedValue(new Error('FS Error'));
+    await command.run();
+    expect(command.error).toHaveBeenCalledWith(expect.stringContaining('Failed to list modules'));
+  });
 });

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

@@ -1,89 +1,96 @@
-import { logger, runCommand } from '@nexical/cli-core';
+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';
 
 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(),
-    };
+  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;
+  let command: ModuleRemoveCommand;
 
-    beforeEach(async () => {
-        vi.clearAllMocks();
-        command = new ModuleRemoveCommand({}, { rootDir: '/mock/root' });
-        vi.spyOn(command, 'error').mockImplementation((() => { }) as any);
-        vi.spyOn(command, 'success').mockImplementation((() => { }) as any);
-        vi.spyOn(command, 'info').mockImplementation((() => { }) as any);
-        vi.mocked(fs.pathExists).mockImplementation(async (p: string) => {
-            if (p.includes('app.yml') || p.includes('nexical.yml')) return true;
-            return true;
-        });
-        vi.spyOn(process, 'exit').mockImplementation((() => { }) as any);
-        await command.init();
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    command = new ModuleRemoveCommand({}, { 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(() => {
-        vi.resetAllMocks();
-    });
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
 
-    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 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 error if project root is missing', async () => {
-        command = new ModuleRemoveCommand({}, { rootDir: undefined });
-        vi.spyOn(command, 'init').mockImplementation(async () => { });
-        vi.spyOn(command, 'error').mockImplementation((() => { }) as any);
+  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(() => {});
 
-        await command.runInit({ name: 'mod' });
-        expect(command.error).toHaveBeenCalledWith(expect.stringContaining('requires to be run within an app project'), 1);
-    });
+    await command.runInit({ name: 'mod' });
+    expect(command.error).toHaveBeenCalledWith(
+      expect.stringContaining('requires to be run within an app project'),
+      1,
+    );
+  });
 
-    it('should remove submodule and sync', async () => {
-        await command.run({ name: 'mod' });
+  it('should remove submodule and sync', async () => {
+    await command.run({ name: 'mod' });
 
-        expect(runCommand).toHaveBeenCalledWith(expect.stringContaining('git submodule deinit'), '/mock/root');
-        expect(runCommand).toHaveBeenCalledWith(expect.stringContaining('git rm'), '/mock/root');
-        expect(fs.remove).toHaveBeenCalledWith(expect.stringContaining('.git/modules'));
-        expect(runCommand).toHaveBeenCalledWith('npm install', '/mock/root');
-    });
+    expect(runCommand).toHaveBeenCalledWith(
+      expect.stringContaining('git submodule deinit'),
+      '/mock/root',
+    );
+    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 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 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 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 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;
-        });
-        await command.run({ name: 'mod' });
-        expect(fs.remove).not.toHaveBeenCalledWith(expect.stringContaining('.git/modules'));
+  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;
     });
+    await command.run({ name: 'mod' });
+    expect(fs.remove).not.toHaveBeenCalledWith(expect.stringContaining('.git/modules'));
+  });
 });

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

@@ -1,91 +1,95 @@
-import { logger, runCommand } from '@nexical/cli-core';
+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';
 
 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(),
-    };
+  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('ModuleUpdateCommand', () => {
-    let command: ModuleUpdateCommand;
+  let command: ModuleUpdateCommand;
 
-    beforeEach(async () => {
-        vi.clearAllMocks();
-        command = new ModuleUpdateCommand({}, { rootDir: '/mock/root' });
-        vi.spyOn(command, 'error').mockImplementation((() => { }) as any);
-        vi.spyOn(command, 'success').mockImplementation((() => { }) as any);
-        vi.spyOn(command, 'info').mockImplementation((() => { }) as any);
-        vi.mocked(fs.pathExists).mockImplementation(async (p: string) => {
-            if (p.includes('app.yml') || p.includes('nexical.yml')) return true;
-            return true;
-        });
-        vi.spyOn(process, 'exit').mockImplementation((() => { }) as any);
-        await command.init();
+  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(() => {
-        vi.resetAllMocks();
-    });
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
 
-    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 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((() => { }) as any);
+  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);
-    });
+    await command.runInit({});
+    expect(command.error).toHaveBeenCalledWith(
+      expect.stringContaining('requires to be run within an app project'),
+      1,
+    );
+  });
 
-    it('should update all modules if no name provided', async () => {
-        await command.run({});
-        expect(runCommand).toHaveBeenCalledWith(
-            expect.stringContaining('git submodule update --remote'),
-            '/mock/root'
-        );
-        expect(runCommand).toHaveBeenCalledWith('npm install', '/mock/root');
-    });
+  it('should update all modules if no name provided', async () => {
+    await command.run({});
+    expect(runCommand).toHaveBeenCalledWith(
+      expect.stringContaining('git submodule update --remote'),
+      '/mock/root',
+    );
+    expect(runCommand).toHaveBeenCalledWith('npm install', '/mock/root');
+  });
 
-    it('should update specific module', async () => {
-        await command.run({ name: 'mod' });
-        expect(runCommand).toHaveBeenCalledWith(
-            expect.stringContaining('git submodule update --remote --merge modules/mod'),
-            '/mock/root'
-        );
-    });
+  it('should update specific module', async () => {
+    await command.run({ name: 'mod' });
+    expect(runCommand).toHaveBeenCalledWith(
+      expect.stringContaining('git submodule update --remote --merge modules/mod'),
+      '/mock/root',
+    );
+  });
 
-    it('should handle failure during update', async () => {
-        vi.mocked(runCommand).mockRejectedValue(new Error('Update failed'));
-        await command.run({});
-        expect(command.error).toHaveBeenCalledWith(expect.stringContaining('Failed to update'));
-    });
+  it('should handle failure during update', async () => {
+    vi.mocked(runCommand).mockRejectedValue(new Error('Update failed'));
+    await command.run({});
+    expect(command.error).toHaveBeenCalledWith(expect.stringContaining('Failed to update'));
+  });
 
-    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 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.');
+  });
 });