@nexical/cli 0.10.0 → 0.11.1

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

@@ -11,134 +11,134 @@ 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,
-    }
+  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.
+  let projectDir: string;
+  let moduleRepo: string;
+  let consoleTableSpy: unknown;
+
+  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: []',
     });
 
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
+    // 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';
 
-    afterAll(async () => {
-        await cleanupTestRoot();
+    // 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";',
     });
 
-    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);
-        }
-    });
+    consoleTableSpy = vi.spyOn(console, 'table').mockImplementation(() => {});
+    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 });
+
+      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

@@ -8,83 +8,90 @@ import { spawn } from 'child_process';
 import EventEmitter from 'events';
 
 vi.mock('child_process', () => ({
-    spawn: vi.fn(),
-    exec: vi.fn(),
+  spawn: vi.fn(),
+  exec: vi.fn(),
 }));
 
 describe('RunCommand Integration', () => {
-    let projectDir: string;
-    let spawnMock: any;
+  let projectDir: string;
+  let spawnMock: ReturnType<typeof vi.mocked>;
 
-    beforeEach(async () => {
-        projectDir = await createTempDir('run-project-');
-        vi.mocked(spawn).mockClear();
+  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'
-            }
-        }));
+    // 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'
-            }
-        }));
+    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;
-        });
+    spawnMock = vi.mocked(spawn).mockImplementation(() => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const child = new EventEmitter() as any;
+      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();
-    });
+  afterEach(() => {
+    vi.clearAllMocks();
+    vi.restoreAllMocks();
+  });
 
-    afterAll(async () => {
-        if (projectDir) await fs.remove(projectDir);
-    });
+  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 });
+  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'] });
+    await command.run({ script: 'test-script', args: ['--flag'] });
 
-        expect(spawnMock).toHaveBeenCalledWith(
-            'npm',
-            ['run', 'test-script', '--', '--flag'],
-            expect.objectContaining({
-                cwd: projectDir
-            })
-        );
-    });
+    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 });
+  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'] });
+    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')
-            })
-        );
-    });
+    // 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

@@ -1,4 +1,3 @@
-
 import { describe, it, expect, beforeAll, afterAll } from 'vitest';
 import path from 'node:path';
 import fs from 'fs-extra';
@@ -14,67 +13,55 @@ const tsxPackagePath = require.resolve('tsx/package.json');
 const tsxDir = path.dirname(tsxPackagePath);
 const TSX_BIN = path.resolve(tsxDir, 'dist/cli.mjs');
 
+// eslint-disable-next-line no-console
 console.log('Using TSX binary at:', TSX_BIN);
 
 describe('Command Loading Integration', () => {
-    beforeAll(async () => {
-        await fs.ensureDir(TEST_TMP_DIR);
-    });
+  beforeAll(async () => {
+    await fs.ensureDir(TEST_TMP_DIR);
+  });
 
-    afterAll(async () => {
-        await fs.remove(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');
+  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);
+    // 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 = {};
+    `;
 
-        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);
 
-        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'
-            }
-        });
+    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);
-        }
+    if (!stdout.includes('Hello from test module!')) {
+      // eslint-disable-next-line no-console
+      console.log('STDOUT:', stdout);
+      // eslint-disable-next-line no-console
+      console.log('STDERR:', stderr);
+    }
 
-        expect(stdout).toContain('Hello from test module!');
-    }, 20000);
+    expect(stdout).toContain('Hello from test module!');
+  }, 20000);
 });