@nexical/cli 0.1.6 → 0.10.0

package/test/unit/commands/init.test.ts

@@ -0,0 +1,153 @@
+import { logger, runCommand } from '@nexical/cli-core';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import InitCommand from '../../../src/commands/init.js';
+import * as git from '../../../src/utils/git.js';
+import fs from 'fs-extra';
+
+vi.mock('@nexical/cli-core', async (importOriginal) => {
+    const mod = await importOriginal<typeof import('@nexical/cli-core')>();
+    return {
+        ...mod,
+        runCommand: vi.fn(),
+        logger: { code: vi.fn(), debug: vi.fn(), error: vi.fn(), success: vi.fn(), info: vi.fn(), warn: vi.fn() }
+    }
+});
+
+vi.mock('../../../src/utils/git.js', () => ({
+    clone: vi.fn(),
+    updateSubmodules: vi.fn(),
+    checkoutOrphan: vi.fn(),
+    addAll: vi.fn(),
+    commit: vi.fn(),
+    deleteBranch: vi.fn(),
+    renameBranch: vi.fn(),
+    removeRemote: vi.fn(),
+    branchExists: vi.fn(),
+    renameRemote: vi.fn(),
+    getRemoteUrl: vi.fn()
+}));
+
+vi.mock('fs-extra');
+
+describe('InitCommand', () => {
+    let command: InitCommand;
+    // Spy on process.exit but rely on catching the error if it throws (default vitest behavior)
+    // or mock it to throw a custom error we can check.
+    let mockExit: any;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        command = new InitCommand({});
+        vi.spyOn(command, 'error').mockImplementation((() => { }) as any);
+        vi.spyOn(command, 'info').mockImplementation((() => { }) as any);
+        vi.spyOn(command, 'success').mockImplementation((() => { }) as any);
+
+        // Default fs mocks
+        vi.mocked(fs.pathExists as any).mockResolvedValue(false); // Target not exist
+        vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+        vi.mocked(fs.readdir).mockResolvedValue([] as any);
+        vi.mocked(fs.copy).mockResolvedValue(undefined);
+        vi.mocked(fs.ensureDir).mockResolvedValue(undefined);
+
+        // Mock process.exit to throw a known error so we can stop execution and verify it
+        mockExit = vi.spyOn(process, 'exit').mockImplementation((code) => {
+            throw new Error(`Process.exit(${code})`);
+        });
+    });
+
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+
+    it('should have correct metadata', () => {
+        expect(InitCommand.description).toBeDefined();
+        expect(InitCommand.args).toBeDefined();
+        expect(InitCommand.requiresProject).toBe(false);
+    });
+
+    it('should initialize project with default repo', async () => {
+        const targetDir = 'new-project';
+        await command.run({ directory: targetDir, repo: 'https://default.com/repo' });
+
+        expect(fs.mkdir).toHaveBeenCalledWith(expect.stringContaining(targetDir), { recursive: true });
+
+        // Clone
+        expect(git.clone).toHaveBeenCalledWith('https://default.com/repo.git', expect.stringContaining(targetDir), { recursive: true });
+
+        // Submodules
+        expect(git.updateSubmodules).toHaveBeenCalledWith(expect.stringContaining(targetDir));
+
+        // Npm install
+        expect(runCommand).toHaveBeenCalledWith(
+            'npm install',
+            expect.stringContaining(targetDir)
+        );
+
+        // Remote rename
+        expect(git.renameRemote).toHaveBeenCalledWith('origin', 'upstream', expect.stringContaining(targetDir));
+
+        // Version and Config creation
+        expect(fs.writeFile).toHaveBeenCalledWith(expect.stringContaining('nexical.yaml'), expect.stringContaining('name: new-project'));
+        expect(fs.writeFile).toHaveBeenCalledWith(expect.stringContaining('VERSION'), '0.1.0');
+
+        expect(git.addAll).toHaveBeenCalledWith(expect.stringContaining(targetDir));
+        expect(git.commit).toHaveBeenCalledWith('Initial site commit', expect.stringContaining(targetDir));
+
+        expect(command.success).toHaveBeenCalledWith(expect.stringContaining('successfully'));
+    });
+
+    it('should skip version and config creation if they already exist', async () => {
+        const targetDir = 'existing-files';
+        vi.mocked(fs.pathExists as any).mockImplementation(async (p: string) => {
+            if (p.includes('nexical.yaml')) return true;
+            if (p.includes('VERSION')) return true;
+            return false;
+        });
+
+        await command.run({ directory: targetDir, repo: 'foo' });
+
+        expect(fs.writeFile).not.toHaveBeenCalledWith(expect.stringContaining('nexical.yaml'), expect.anything());
+        expect(fs.writeFile).not.toHaveBeenCalledWith(expect.stringContaining('VERSION'), expect.anything());
+    });
+
+    it('should handle gh@ syntax', async () => {
+        const targetDir = 'gh-project';
+        await command.run({ directory: targetDir, repo: 'gh@nexical/nexical-starter' });
+
+        expect(git.clone).toHaveBeenCalledWith(
+            'https://github.com/nexical/nexical-starter.git',
+            expect.stringContaining(targetDir),
+            { recursive: true }
+        );
+    });
+
+    it('should proceed if directory exists but is empty', async () => {
+        vi.mocked(fs.pathExists as any).mockResolvedValue(true);
+        vi.mocked(fs.readdir).mockResolvedValue([] as any);
+
+        await command.run({ directory: 'empty-dir', repo: 'foo' });
+
+        expect(fs.mkdir).not.toHaveBeenCalled(); // Should assume dir exists
+        expect(git.clone).toHaveBeenCalledWith('foo.git', expect.stringContaining('empty-dir'), { recursive: true });
+    });
+
+    it('should fail if directory exists and is not empty', async () => {
+        // First exists check for targetDir
+        vi.mocked(fs.pathExists as any).mockResolvedValue(true);
+        vi.mocked(fs.readdir).mockResolvedValue(['file.txt'] as any);
+
+        await expect(command.run({ directory: 'existing-dir', repo: 'foo' }))
+            .rejects.toThrow('Process.exit(1)');
+
+        expect(command.error).toHaveBeenCalledWith(expect.stringContaining('not empty'));
+    });
+
+    it('should handle git errors gracefully', async () => {
+        vi.mocked(git.clone).mockRejectedValueOnce(new Error('Git fail'));
+
+        await expect(command.run({ directory: 'fail-project', repo: 'foo' }))
+            .rejects.toThrow('Process.exit(1)');
+
+        expect(command.error).toHaveBeenCalledWith(expect.stringContaining('Failed to initialize project'));
+    });
+});

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

@@ -0,0 +1,262 @@
+import { logger, runCommand } from '@nexical/cli-core';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import ModuleAddCommand from '../../../../src/commands/module/add.js';
+import fs from 'fs-extra';
+import * as git from '../../../../src/utils/git.js';
+
+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');
+vi.mock('../../../../src/utils/git.js', () => ({
+    clone: vi.fn(),
+    updateSubmodules: vi.fn(),
+    checkoutOrphan: vi.fn(),
+    addAll: vi.fn(),
+    commit: vi.fn(),
+    deleteBranch: vi.fn(),
+    renameBranch: vi.fn(),
+    removeRemote: vi.fn(),
+    branchExists: vi.fn(),
+    renameRemote: vi.fn(),
+    getRemoteUrl: vi.fn()
+}));
+
+describe('ModuleAddCommand', () => {
+    let command: ModuleAddCommand;
+
+    beforeEach(async () => {
+        vi.clearAllMocks();
+        command = new ModuleAddCommand({}, { rootDir: '/mock/root' });
+        vi.spyOn(command, 'error').mockImplementation((() => { }) as any);
+        vi.spyOn(command, 'success').mockImplementation((() => { }) as any);
+        vi.spyOn(command, 'info').mockImplementation((() => { }) as any);
+
+        // Setup mocks
+        vi.mocked(fs.ensureDir).mockImplementation(async () => { });
+        vi.mocked(fs.remove).mockImplementation(async () => { });
+        vi.mocked(fs.pathExists).mockImplementation(async (p: string) => {
+            // We don't rely on this for init anymore since we force projectRoot
+            return false;
+        });
+        vi.mocked(fs.readFile).mockResolvedValue('name: test-module\n' as any);
+
+        // Mock git default behaviors
+        vi.mocked(git.clone).mockResolvedValue(undefined as any);
+        vi.mocked(git.getRemoteUrl).mockResolvedValue('' as any);
+
+        // Force project root
+        await command.init();
+        (command as any).projectRoot = '/mock/root';
+    });
+
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+
+    it('should have correct static properties', () => {
+        expect(ModuleAddCommand.usage).toContain('module add');
+        expect(ModuleAddCommand.description).toBeDefined();
+        expect(ModuleAddCommand.requiresProject).toBe(true);
+        expect(ModuleAddCommand.args).toBeDefined();
+    });
+
+    it('should error if project root is missing', async () => {
+        command = new ModuleAddCommand({}, { rootDir: undefined });
+        vi.spyOn(command, 'error').mockImplementation(() => { });
+        // Ensure init doesn't set it (mocked in beforeEach but this constructor overrides logic?)
+        // In beforeEach, we call command.init() then set projectRoot. 
+        // Here we just created new command.
+        vi.spyOn(command, 'init').mockImplementation(async () => { });
+
+        await command.runInit({ url: 'arg' });
+        expect(command.error).toHaveBeenCalledWith(expect.stringContaining('requires to be run within an app project'), 1);
+    });
+
+    it('should handle gh@ syntax with .git suffix', async () => {
+        // We mock fs.pathExists to return false for targetDir to trigger install
+        // return true for stagingDir to simulate clone success
+        // return true for module.yaml check
+        vi.mocked(fs.pathExists).mockResolvedValue(false as any); // Default
+
+        await command.run({ url: 'gh@org/repo.git' }); // With .git suffix
+
+        // Should NOT append another .git
+        expect(git.clone).toHaveBeenCalledWith(
+            'https://github.com/org/repo.git',
+            expect.any(String),
+            expect.objectContaining({ depth: 1 })
+        );
+    });
+
+    it('should error if url is missing', async () => {
+        await command.run({ url: undefined });
+        expect(command.error).toHaveBeenCalledWith('Please specify a repository URL.');
+    });
+
+    it('should error if module.yaml is missing', async () => {
+        vi.mocked(fs.pathExists).mockResolvedValue(false as any); // No yaml found
+        await command.run({ url: 'https://github.com/org/repo.git' });
+        expect(command.error).toHaveBeenCalledWith(expect.stringContaining('No module.yaml found'));
+    });
+
+    it('should error if module.yaml is missing in subdirectory', async () => {
+        vi.mocked(fs.pathExists).mockResolvedValue(false as any); // No yaml
+
+        // We mocked fs.pathExists to return false for everything in this test setup unless selective
+        // But the run() logic:
+        // await clone(...)
+        // if (subPath) ...
+        // if (!exists) throw
+
+        await command.run({ url: 'https://github.com/org/repo.git//subdir' });
+        expect(command.error).toHaveBeenCalledWith(expect.stringContaining('No module.yaml found in https://github.com/org/repo.git//subdir'));
+    });
+
+    it('should error if name is missing in module.yaml', async () => {
+        vi.mocked(fs.pathExists).mockResolvedValueOnce(false as any).mockResolvedValueOnce(true as any);
+        vi.mocked(fs.readFile).mockResolvedValueOnce('dependencies: []' as any); // No name
+        await command.run({ url: 'https://github.com/org/repo.git' });
+        expect(command.error).toHaveBeenCalledWith(expect.stringContaining('missing \'name\' in module.yaml'));
+    });
+
+    it('should handle generic errors during install', async () => {
+        vi.mocked(git.clone).mockRejectedValue(new Error('Clone failed'));
+        await command.run({ url: 'https://github.com/org/repo.git' });
+        expect(command.error).toHaveBeenCalledWith(expect.stringContaining('Failed to add module: Clone failed'));
+    });
+
+    it('should install a module using git submodule add', async () => {
+        vi.mocked(fs.pathExists).mockResolvedValueOnce(false as any); // Staging yaml
+        vi.mocked(fs.pathExists).mockResolvedValueOnce(true as any);  // module.yaml in staging exists
+        vi.mocked(fs.readFile).mockResolvedValueOnce('name: my-module\n' as any);
+
+        await command.run({ url: 'https://github.com/org/repo.git' });
+
+        expect(git.clone).toHaveBeenCalledWith(
+            'https://github.com/org/repo.git',
+            expect.stringContaining('staging-'),
+            { depth: 1 }
+        );
+
+        // Should use submodule add
+        expect(runCommand).toHaveBeenCalledWith(
+            expect.stringContaining('git submodule add https://github.com/org/repo.git modules/my-module'),
+            '/mock/root'
+        );
+
+        expect(runCommand).toHaveBeenCalledWith('npm install', '/mock/root');
+        expect(command.success).toHaveBeenCalledWith('All modules installed successfully.');
+    });
+
+    it('should recursively install dependencies', async () => {
+        // First module calls
+        vi.mocked(fs.pathExists)
+            .mockResolvedValueOnce(false as any).mockResolvedValueOnce(true as any) // module 1 yaml exists
+            .mockResolvedValueOnce(false as any) // target dir check
+            .mockResolvedValueOnce(false as any).mockResolvedValueOnce(true as any) // module 2 yaml exists
+            .mockResolvedValueOnce(false as any); // target dir check
+
+        vi.mocked(fs.readFile)
+            .mockResolvedValueOnce('name: parent\ndependencies:\n  - gh@org/child' as any)
+            .mockResolvedValueOnce('name: child' as any);
+
+        await command.run({ url: 'gh@org/parent' });
+
+        // Should clone parent
+        expect(git.clone).toHaveBeenCalledWith(
+            expect.stringContaining('parent.git'),
+            expect.anything(),
+            expect.anything()
+        );
+        // Should clone child
+        expect(git.clone).toHaveBeenCalledWith(
+            expect.stringContaining('child.git'),
+            expect.anything(),
+            expect.anything()
+        );
+
+        expect(runCommand).toHaveBeenCalledTimes(3); // 2 submodules + npm install
+    });
+
+    it('should handle object-style dependencies', async () => {
+        vi.mocked(fs.pathExists)
+            .mockResolvedValueOnce(false as any).mockResolvedValueOnce(true as any) // module exists
+            .mockResolvedValueOnce(false as any); // target dir check
+
+        vi.mocked(fs.readFile)
+            .mockResolvedValueOnce('name: parent\ndependencies:\n  gh@org/child: main' as any); // Object style
+
+        await command.run({ url: 'gh@org/parent' });
+
+        expect(git.clone).toHaveBeenCalledTimes(2); // parent + child
+    });
+
+    it('should detect conflicts (installed but different origin)', async () => {
+        vi.mocked(fs.pathExists).mockResolvedValueOnce(false as any).mockResolvedValueOnce(true as any); // staging yaml
+        vi.mocked(fs.readFile).mockResolvedValueOnce('name: conflict-mod' as any);
+
+        // Target dir check returns true (exists)
+        vi.mocked(fs.pathExists).mockResolvedValueOnce(true as any);
+
+        // Origin check returns different URL
+        vi.mocked(git.getRemoteUrl).mockResolvedValueOnce('https://other.com/repo.git' as any);
+
+        await command.run({ url: 'https://github.com/org/repo.git' });
+
+        expect(command.error).toHaveBeenCalledWith(
+            expect.stringContaining('Dependency Conflict! Module \'conflict-mod\' exists but remote')
+        );
+    });
+
+    it('should skip installation if same module/origin already exists', async () => {
+        vi.mocked(fs.pathExists).mockResolvedValueOnce(false as any).mockResolvedValueOnce(true as any); // staging yaml
+        vi.mocked(fs.readFile).mockResolvedValueOnce('name: existing-mod' as any);
+        vi.mocked(fs.pathExists).mockResolvedValueOnce(true as any); // Exists
+        vi.mocked(git.getRemoteUrl).mockResolvedValueOnce('https://github.com/org/repo.git' as any); // Same URL
+
+        await command.run({ url: 'https://github.com/org/repo.git' });
+
+        expect(command.info).toHaveBeenCalledWith('Module existing-mod already installed.');
+        // Should NOT call submodule add
+        expect(runCommand).not.toHaveBeenCalledWith(expect.stringContaining('git submodule add'), expect.anything());
+        // But SHOULD call npm install at end
+        expect(runCommand).toHaveBeenCalledWith('npm install', '/mock/root');
+    });
+
+    it('should handle circular dependencies', async () => {
+        // Module A depends on B, B depends on A
+        // A
+        vi.mocked(fs.pathExists).mockResolvedValue(true as any); // Simplify pathExists to always true for yamls
+        vi.mocked(fs.readFile)
+            .mockResolvedValueOnce('name: mod-a\ndependencies:\n  - gh@org/mod-b' as any)
+            .mockResolvedValueOnce('name: mod-b\ndependencies:\n  - gh@org/mod-a' as any);
+
+        // Target dir checks (false = not installed)
+        // We need to carefully mock pathExists sequence or use implementation based on path
+        vi.mocked(fs.pathExists).mockImplementation(async (p: string) => {
+            if (p.includes('modules')) return false; // Not installed yet
+            return true; // Yaml exists
+        });
+
+        await command.run({ url: 'gh@org/mod-a' });
+
+        // Should install A and B, then see A again and skip
+        expect(git.clone).toHaveBeenCalledTimes(2);
+        // Should succeed
+        expect(command.success).toHaveBeenCalled();
+    });
+});
+

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

@@ -0,0 +1,115 @@
+import { BaseCommand, logger } 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(),
+    };
+});
+vi.mock('fs-extra');
+
+describe('ModuleListCommand', () => {
+    let command: ModuleListCommand;
+    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();
+    });
+
+    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 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);
+    });
+
+    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));
+
+        // 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 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' };
+        });
+
+        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: '' }
+        ]));
+    });
+
+    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 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

@@ -0,0 +1,89 @@
+import { logger, 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(),
+    };
+});
+vi.mock('fs-extra');
+
+describe('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();
+    });
+
+    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 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);
+
+        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' });
+
+        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 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'));
+    });
+});