@nexical/cli 0.1.7 → 0.10.0

package/test/integration/commands/init.integration.test.ts

@@ -0,0 +1,82 @@
+import { CLI } from '@nexical/cli-core';
+import { describe, it, expect, beforeEach, afterEach, afterAll } from 'vitest';
+import InitCommand from '../../../src/commands/init.js';
+import { createTempDir, createMockRepo, cleanupTestRoot } from '../../utils/integration-helpers.js';
+import path from 'node:path';
+import fs from 'fs-extra';
+import { execa } from 'execa';
+
+describe('InitCommand Integration', () => {
+    let tempDir: string;
+    let starterRepoDir: string;
+
+    beforeEach(async () => {
+        tempDir = await createTempDir('init-integration-');
+        const starterDir = await createTempDir('starter-repo-');
+
+        // precise setup of a starter repo
+        starterRepoDir = await createMockRepo(starterDir, {
+            'package.json': JSON.stringify({
+                name: 'nexical-starter',
+                version: '0.0.0',
+                dependencies: {
+                    'is-odd': '3.0.1'
+                }
+            }),
+            'README.md': '# Starter Template'
+        });
+
+        // Set Git Identity for the test process so InitCommand's commit works in CI
+        process.env.GIT_AUTHOR_NAME = 'Test User';
+        process.env.GIT_AUTHOR_EMAIL = 'test@example.com';
+        process.env.GIT_COMMITTER_NAME = 'Test User';
+        process.env.GIT_COMMITTER_EMAIL = 'test@example.com';
+        // Allow file protocol for local cloning in CI
+        process.env.GIT_ALLOW_PROTOCOL = 'file';
+    });
+
+    afterAll(async () => {
+        // await cleanupTestRoot(); // conflicting with parallel tests
+        if (tempDir) await fs.remove(tempDir);
+    });
+
+    it('should initialize a new project from a local git repo', async () => {
+        const targetProjectName = 'my-new-project';
+        const targetPath = path.join(tempDir, targetProjectName);
+        const cli = new CLI({ commandName: 'nexical' });
+
+        const command = new InitCommand(cli);
+
+        // Capture stdout/stderr? InitCommand uses consola.
+        // For integration, we care about the FS side effects.
+
+        await command.run({
+            directory: targetPath,
+            repo: starterRepoDir // Passing local path as repo URL
+        });
+
+        // 1. Check directory exists
+        expect(fs.existsSync(targetPath)).toBe(true);
+
+        // 2. Check files cloned
+        expect(fs.existsSync(path.join(targetPath, 'package.json'))).toBe(true);
+        expect(fs.existsSync(path.join(targetPath, 'README.md'))).toBe(true);
+
+        // 3. Check git initialization
+        expect(fs.existsSync(path.join(targetPath, '.git'))).toBe(true);
+
+        // 4. Check git initialization (history should be preserved + one new commit)
+        const { stdout: log } = await execa('git', ['log', '--oneline'], { cwd: targetPath });
+        const lines = log.split('\n').filter(Boolean);
+        expect(lines.length).toBe(2); // Should have "Initial site commit" and "Initial commit"
+        expect(lines[0]).toContain('Initial site commit');
+        expect(lines[1]).toContain('Initial commit');
+
+        // 5. Check dependencies (optional, but command tries to install them)
+        // Since we are mocking the repo, it doesn't have a real lockfile or valid deps,
+        // so `npm install` might have failed or done nothing.
+        // However, `InitCommand` runs `npm install`. If that fails, the command throws/exits.
+        // We provided a minimal package.json so it should succeed.
+        expect(fs.existsSync(path.join(targetPath, 'node_modules'))).toBe(true);
+    }, 60000); // Increase timeout for real git/npm ops
+});

package/test/integration/commands/module.integration.test.ts

@@ -0,0 +1,144 @@
+import { CLI } from '@nexical/cli-core';
+import { describe, it, expect, beforeEach, afterEach, afterAll, vi } from 'vitest';
+import ModuleAddCommand from '../../../src/commands/module/add.js';
+import ModuleRemoveCommand from '../../../src/commands/module/remove.js';
+import ModuleListCommand from '../../../src/commands/module/list.js';
+import ModuleUpdateCommand from '../../../src/commands/module/update.js';
+
+import { createTempDir, createMockRepo, cleanupTestRoot } from '../../utils/integration-helpers.js';
+import path from 'node:path';
+import fs from 'fs-extra';
+
+// Mock picocolors to return strings as-is for easy matching
+vi.mock('picocolors', () => ({
+    default: {
+        bold: (s: string) => s,
+        cyan: (s: string) => s,
+        yellow: (s: string) => s,
+        dim: (s: string) => s,
+        red: (s: string) => s,
+        green: (s: string) => s,
+        blue: (s: string) => s,
+        magenta: (s: string) => s,
+    }
+}));
+
+describe('Module Commands Integration', () => {
+    let projectDir: string;
+    let moduleRepo: string;
+    let consoleTableSpy: any;
+    let consoleLogSpy: any;
+
+    beforeEach(async () => {
+        // 1. Create a "Project" that is a git repo
+        const temp = await createTempDir('module-project-');
+        projectDir = await createMockRepo(temp, {
+            'package.json': '{"name": "test-project", "version": "1.0.0"}',
+            'nexical.yaml': 'site: test\nmodules: []'
+        });
+
+        // Allow file protocol for submodules in this repo
+        // await execa('git', ['config', 'protocol.file.allow', 'always'], { cwd: projectDir }); // Config approach failed
+        process.env.GIT_ALLOW_PROTOCOL = 'file';
+
+        // 2. Create a "Module" that is a SEPARATE git repo
+        const modTemp = await createTempDir('module-source-');
+        moduleRepo = await createMockRepo(modTemp, {
+            'package.json': '{"name": "my-module", "version": "1.0.0", "description": "Awesome module"}',
+            'module.yaml': 'name: my-module\nversion: 1.0.0',
+            'index.ts': 'export const hello = "world";'
+        });
+
+        consoleTableSpy = vi.spyOn(console, 'table').mockImplementation(() => { });
+        consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+
+        // Switch CWD to project for commands to find root
+        // Note: process.chdir behavior might persist, so we rely on mocking or careful cleanup
+        // But integration tests run sequentially in same thread usually with vitest unless configured otherwise.
+        // We will pass specific CWD to commands if possible, OR chdir and restore.
+    });
+
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+
+    afterAll(async () => {
+        await cleanupTestRoot();
+    });
+
+    it('should add, list, update and remove a module', async () => {
+        const originalCwd = process.cwd();
+        const cli = new CLI({ commandName: 'nexical' });
+        try {
+            process.chdir(projectDir);
+
+            // 1. ADD MODULE
+            const addCmd = new ModuleAddCommand(cli);
+
+            await addCmd.init();
+            await addCmd.run({ url: moduleRepo, name: 'my-module' });
+
+            const modulePath = path.join(projectDir, 'modules/my-module');
+            expect(fs.existsSync(modulePath)).toBe(true);
+            expect(fs.existsSync(path.join(modulePath, 'package.json'))).toBe(true);
+
+            // Verify nexical.yaml updated
+            const config = await fs.readFile(path.join(projectDir, 'nexical.yaml'), 'utf8');
+            expect(config).toContain('modules:');
+            expect(config).toContain('- my-module');
+
+            // Check it is a submodule
+            // .git file in module dir pointing to gitdir
+            expect(fs.existsSync(path.join(modulePath, '.git'))).toBe(true);
+            const gitModules = await fs.readFile(path.join(projectDir, '.gitmodules'), 'utf-8');
+            expect(gitModules).toContain('path = modules/my-module');
+
+            // 2. LIST MODULES with valid module
+            const listCmd = new ModuleListCommand(cli);
+            await listCmd.init();
+            await listCmd.run();
+
+            // Check console.table called with module info
+            expect(consoleTableSpy).toHaveBeenCalledWith(expect.arrayContaining([
+                expect.objectContaining({
+                    name: 'my-module',
+                    version: '1.0.0',
+                    description: 'Awesome module'
+                })
+            ]));
+
+            // 3. UPDATE MODULE
+            const updateCmd = new ModuleUpdateCommand(cli);
+            await updateCmd.init();
+            await updateCmd.run({ name: 'my-module' });
+            // Hard to check "update" without changing the remote first.
+            // But we verify it ran without throwing.
+
+            // 4. REMOVE MODULE
+            const removeCmd = new ModuleRemoveCommand(cli);
+            await removeCmd.init();
+            await removeCmd.run({ name: 'my-module' });
+
+            expect(fs.existsSync(modulePath)).toBe(false);
+
+            // Verify git cleanup
+            // .git/modules/modules/my-module should be gone
+            const gitInternalModuleDir = path.join(projectDir, '.git/modules/modules/my-module');
+            expect(fs.existsSync(gitInternalModuleDir)).toBe(false);
+
+            // .gitmodules entry gone? `git rm` usually handles this.
+            // Check if .gitmodules file exists (if empty it might remain or be deleted depending on git version, usually implicitly updated)
+            if (fs.existsSync(path.join(projectDir, '.gitmodules'))) {
+                const updatedGitModules = await fs.readFile(path.join(projectDir, '.gitmodules'), 'utf-8');
+                expect(updatedGitModules).not.toContain('modules/my-module');
+            }
+
+            // Verify nexical.yaml updated
+            const configRemoved = await fs.readFile(path.join(projectDir, 'nexical.yaml'), 'utf8');
+            expect(configRemoved).not.toContain('- my-module');
+
+        } finally {
+            process.chdir(originalCwd);
+        }
+    });
+});

package/test/integration/commands/run.integration.test.ts

@@ -0,0 +1,90 @@
+import { CLI } from '@nexical/cli-core';
+import { describe, it, expect, beforeEach, afterEach, afterAll, vi } from 'vitest';
+import RunCommand from '../../../src/commands/run.js';
+import { createTempDir } from '../../utils/integration-helpers.js';
+import path from 'node:path';
+import fs from 'fs-extra';
+import { spawn } from 'child_process';
+import EventEmitter from 'events';
+
+vi.mock('child_process', () => ({
+    spawn: vi.fn(),
+    exec: vi.fn(),
+}));
+
+describe('RunCommand Integration', () => {
+    let projectDir: string;
+    let spawnMock: any;
+
+    beforeEach(async () => {
+        projectDir = await createTempDir('run-project-');
+        vi.mocked(spawn).mockClear();
+
+        // Setup minimal env (New Architecture: no site/ directory)
+        await fs.ensureDir(projectDir);
+        await fs.outputFile(path.join(projectDir, 'package.json'), JSON.stringify({
+            name: 'nexical-core',
+            scripts: {
+                'test-script': 'echo test'
+            }
+        }));
+
+        await fs.ensureDir(path.join(projectDir, 'modules', 'my-auth'));
+        await fs.outputFile(path.join(projectDir, 'modules', 'my-auth', 'package.json'), JSON.stringify({
+            scripts: {
+                'seed': 'node seed.js'
+            }
+        }));
+
+        spawnMock = vi.mocked(spawn).mockImplementation(() => {
+            const child: any = new EventEmitter();
+            child.stdout = new EventEmitter();
+            child.stderr = new EventEmitter();
+            setTimeout(() => child.emit('close', 0), 10);
+            child.kill = vi.fn();
+            return child;
+        });
+    });
+
+    afterEach(() => {
+        vi.clearAllMocks();
+        vi.restoreAllMocks();
+    });
+
+    afterAll(async () => {
+        if (projectDir) await fs.remove(projectDir);
+    });
+
+    it('should run standard npm scripts', async () => {
+        const cli = new CLI({ commandName: 'nexical' });
+        const command = new RunCommand(cli);
+        Object.assign(command, { projectRoot: projectDir });
+
+        await command.run({ script: 'test-script', args: ['--flag'] });
+
+        expect(spawnMock).toHaveBeenCalledWith(
+            'npm',
+            ['run', 'test-script', '--', '--flag'],
+            expect.objectContaining({
+                cwd: projectDir
+            })
+        );
+    });
+
+    it('should run module specific scripts', async () => {
+        const cli = new CLI({ commandName: 'nexical' });
+        const command = new RunCommand(cli);
+        Object.assign(command, { projectRoot: projectDir });
+
+        await command.run({ script: 'my-auth:seed', args: ['--force'] });
+
+        // Module scripts run via npm run scriptName inside module dir
+        expect(spawnMock).toHaveBeenCalledWith(
+            'npm',
+            ['run', 'seed', '--', '--force'],
+            expect.objectContaining({
+                cwd: path.resolve(projectDir, 'modules', 'my-auth')
+            })
+        );
+    });
+});

package/test/integration/utils/command-loading.integration.test.ts

@@ -0,0 +1,80 @@
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import path from 'node:path';
+import fs from 'fs-extra';
+import { execa } from 'execa';
+
+const CLI_ENTRY = path.resolve(__dirname, '../../../index.ts');
+const TEST_TMP_DIR = path.resolve(__dirname, '../../.test-tmp/command-loading');
+
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const tsxPackagePath = require.resolve('tsx/package.json');
+const tsxDir = path.dirname(tsxPackagePath);
+const TSX_BIN = path.resolve(tsxDir, 'dist/cli.mjs');
+
+console.log('Using TSX binary at:', TSX_BIN);
+
+describe('Command Loading Integration', () => {
+    beforeAll(async () => {
+        await fs.ensureDir(TEST_TMP_DIR);
+    });
+
+    afterAll(async () => {
+        await fs.remove(TEST_TMP_DIR);
+    });
+
+    it('should load commands from modules', async () => {
+        // Create nexical.yaml to mock project root
+        await fs.writeFile(path.join(TEST_TMP_DIR, 'nexical.yaml'), 'name: test-project');
+
+        // Setup module structure
+        const moduleDir = path.join(TEST_TMP_DIR, 'src/modules/test-mod/src/commands');
+        await fs.ensureDir(moduleDir);
+
+        const commandFile = path.join(moduleDir, 'hello.ts');
+        const commandContent = `
+            import { BaseCommand } from '@nexical/cli-core';
+            export default class HelloCommand extends BaseCommand {
+                static description = 'Test hello command';
+                static args = {
+                     args: [{ name: 'name', required: false }]
+                };
+                
+                async run(options: any) {
+                    console.log('Hello from test module!');
+                }
+            }
+        `;
+
+        const jsCommandContent = `
+            export default class HelloCommand {
+                constructor(cli) { this.cli = cli; }
+                async init() {}
+                async runInit(options) { return this.run(options); }
+                async run() { console.log('Hello from test module!'); }
+            }
+            HelloCommand.description = 'Test hello command';
+            HelloCommand.args = {};
+        `;
+
+        await fs.writeFile(path.join(moduleDir, 'hello.js'), jsCommandContent);
+
+        const { stdout, stderr } = await execa('node', [TSX_BIN, CLI_ENTRY, 'hello', '--debug'], {
+            cwd: TEST_TMP_DIR,
+            reject: false,
+            env: {
+                ...process.env,
+                FORCE_COLOR: '0'
+            }
+        });
+
+        if (!stdout.includes('Hello from test module!')) {
+            console.log('STDOUT:', stdout);
+            console.log('STDERR:', stderr);
+        }
+
+        expect(stdout).toContain('Hello from test module!');
+    }, 20000);
+});

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'));
+    });
+});