@nexical/cli-core 0.1.0

package/test/unit/core/CommandLoader.test.ts

@@ -0,0 +1,200 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { CLI } from '../../../src/CLI.js';
+import { CommandLoader } from '../../../src/CommandLoader.js';
+import { BaseCommand } from '../../../src/BaseCommand.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { logger } from '../../../src/utils/logger.js';
+
+vi.mock('node:fs');
+vi.mock('../../../src/utils/logger.js', () => ({
+    logger: {
+        debug: vi.fn(),
+        error: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        success: vi.fn()
+    }
+}));
+
+class MockCommand extends BaseCommand {
+    async run() { }
+}
+
+describe('CommandLoader', () => {
+    let loader: CommandLoader;
+    let cli: any;
+    let mockImporter: any;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        cli = new CLI({ commandName: 'app' });
+        mockImporter = vi.fn();
+        loader = new CommandLoader(cli, mockImporter);
+    });
+
+    it('should ignore index.ts if it does not map to a command', async () => {
+        const rootDir = '/commands';
+        (fs.existsSync as any).mockReturnValue(true);
+        (fs.readdirSync as any).mockReturnValue(['index.ts']);
+        (fs.statSync as any).mockReturnValue({ isDirectory: () => false });
+
+        const commands = await loader.load(rootDir);
+        expect(commands).toHaveLength(0);
+    });
+
+    it('should skip directory if does not exist', async () => {
+        (fs.existsSync as any).mockReturnValue(false);
+        const commands = await loader.load('/non-existent');
+        expect(commands).toHaveLength(0);
+    });
+
+    it('should handle class loading error gracefully', async () => {
+        const rootDir = '/commands';
+        (fs.existsSync as any).mockReturnValue(true);
+        (fs.readdirSync as any).mockReturnValue(['error.ts']);
+        (fs.statSync as any).mockReturnValue({ isDirectory: () => false });
+
+        mockImporter.mockRejectedValue(new Error('Load failed'));
+
+        const commands = await loader.load(rootDir);
+
+        expect(commands).toHaveLength(0);
+        expect(logger.error).toHaveBeenCalled();
+    });
+
+    it('should skip files that do not default export a class', async () => {
+        const rootDir = '/commands';
+        (fs.existsSync as any).mockReturnValue(true);
+        (fs.readdirSync as any).mockReturnValue(['no_class.ts']);
+        (fs.statSync as any).mockReturnValue({ isDirectory: () => false });
+        //   - module/ (dir)
+        //     - add.ts
+
+        (fs.readdirSync as any).mockImplementation((p: string) => {
+            if (p === rootDir) return ['create.ts', 'module'];
+            if (p === path.join(rootDir, 'module')) return ['add.ts'];
+            return [];
+        });
+
+        (fs.statSync as any).mockImplementation((p: string) => ({
+            isDirectory: () => {
+                if (p === path.join(rootDir, 'module')) return true;
+                return false;
+            }
+        }));
+
+        // Mock valid command class
+        class MockRecursiveCommand extends BaseCommand {
+            async run() { }
+        }
+        mockImporter.mockResolvedValue({ default: MockRecursiveCommand });
+
+        const commands = await loader.load(rootDir);
+
+        expect(commands).toHaveLength(2);
+
+        const moduleAdd = commands.find(c => c.command === 'module add');
+        expect(moduleAdd).toBeDefined();
+        expect(moduleAdd?.path).toBe(path.join(rootDir, 'module', 'add.ts'));
+    });
+    it('should use default importer if none provided', () => {
+        const cli = new CLI({ commandName: 'app' });
+        const defaultLoader = new CommandLoader(cli);
+        expect(defaultLoader).toBeDefined();
+    });
+    it('should attempt default import execution', async () => {
+        // This test ensures the default parameter (p) => import(p) is executed.
+        // It will fail to import 'fake.ts' but that's caught.
+
+        const cli = new CLI({ commandName: 'app' });
+        const loader = new CommandLoader(cli); // Default importer
+        const rootDir = '/commands';
+        (fs.existsSync as any).mockReturnValue(true);
+        (fs.readdirSync as any).mockReturnValue(['fake.ts']);
+        (fs.statSync as any).mockReturnValue({ isDirectory: () => false });
+
+        // Suppress error log
+        // const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+
+        await loader.load(rootDir);
+
+        // If we reach here, we survived the import error, meaning the catch block was hit
+        // and impliedly the try block (and importer) was executed.
+        expect(logger.error).toHaveBeenCalled();
+    });
+
+    it('should load .js files', async () => {
+        const rootDir = '/commands';
+        (fs.existsSync as any).mockReturnValue(true);
+        (fs.readdirSync as any).mockReturnValue(['script.js']);
+        (fs.statSync as any).mockReturnValue({ isDirectory: () => false });
+
+        class JsCommand extends BaseCommand { async run() { } }
+        mockImporter.mockResolvedValue({ default: JsCommand });
+
+        const commands = await loader.load(rootDir);
+        expect(commands).toHaveLength(1);
+        expect(commands[0].command).toBe('script');
+    });
+    it('should support nested index.ts as parent command', async () => {
+        // Structure: /commands/module/index.ts -> "module"
+        const rootDir = '/commands';
+        (fs.existsSync as any).mockReturnValue(true);
+
+        (fs.readdirSync as any).mockImplementation((p: string) => {
+            if (p === rootDir) return ['module'];
+            if (p === path.join(rootDir, 'module')) return ['index.ts'];
+            return [];
+        });
+
+        (fs.statSync as any).mockImplementation((p: string) => ({
+            isDirectory: () => {
+                if (p === path.join(rootDir, 'module')) return true;
+                return false;
+            }
+        }));
+
+        class ModuleIndexCommand extends BaseCommand { async run() { } }
+        mockImporter.mockResolvedValue({ default: ModuleIndexCommand });
+
+        const commands = await loader.load(rootDir);
+        expect(commands).toHaveLength(1);
+        expect(commands[0].command).toBe('module');
+        expect(commands[0].path).toBe(path.join(rootDir, 'module', 'index.ts'));
+    });
+
+    it('should ignore files with non-executable extensions', async () => {
+        const rootDir = '/commands';
+        (fs.existsSync as any).mockReturnValue(true);
+        (fs.readdirSync as any).mockReturnValue(['readme.md', 'styles.css']);
+        (fs.statSync as any).mockReturnValue({ isDirectory: () => false });
+
+        const commands = await loader.load(rootDir);
+        expect(commands).toHaveLength(0);
+    });
+    it('should skip files that export null', async () => {
+        const rootDir = '/commands';
+        (fs.existsSync as any).mockReturnValue(true);
+        (fs.readdirSync as any).mockReturnValue(['null_export.ts']);
+        (fs.statSync as any).mockReturnValue({ isDirectory: () => false });
+
+        mockImporter.mockResolvedValue({ default: null });
+
+        const commands = await loader.load(rootDir);
+        expect(commands).toHaveLength(0);
+    });
+
+    it('should skip index.ts at root level', async () => {
+        const rootDir = '/commands';
+        (fs.existsSync as any).mockReturnValue(true);
+        (fs.readdirSync as any).mockReturnValue(['index.ts']);
+        (fs.statSync as any).mockReturnValue({ isDirectory: () => false });
+
+        class RootIndexCommand extends BaseCommand { async run() { } }
+        mockImporter.mockResolvedValue({ default: RootIndexCommand });
+
+        const commands = await loader.load(rootDir);
+        expect(commands).toHaveLength(0);
+    });
+});

package/test/unit/utils/config.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { findProjectRoot, loadConfig } from '../../../src/utils/config.js';
+import { lilconfig } from 'lilconfig';
+import path from 'node:path';
+
+// Mock lilconfig
+vi.mock('lilconfig');
+
+describe('Config Utilities', () => {
+    const mockSearch = vi.fn();
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        (lilconfig as any).mockReturnValue({
+            search: mockSearch,
+        });
+    });
+
+    describe('findProjectRoot', () => {
+        it('should return null if no config found', async () => {
+            mockSearch.mockResolvedValue(null);
+            const root = await findProjectRoot('app', '/some/path');
+            expect(root).toBeNull();
+        });
+
+        it('should return directory path if config found', async () => {
+            mockSearch.mockResolvedValue({
+                filepath: '/abs/path/to/app.yml',
+                config: {},
+            });
+            const root = await findProjectRoot('app', '/some/path');
+            expect(root).toBe('/abs/path/to');
+        });
+    });
+
+    describe('loadConfig', () => {
+        it('should return empty object if no config found', async () => {
+            mockSearch.mockResolvedValue(null);
+            const config = await loadConfig('app', '/some/path');
+            expect(config).toEqual({});
+        });
+
+        it('should return config object if found', async () => {
+            const mockConfig = { project: 'test' };
+            mockSearch.mockResolvedValue({
+                filepath: '/abs/path/to/app.yml',
+                config: mockConfig,
+            });
+            const config = await loadConfig('app', '/some/path');
+            expect(config).toEqual(mockConfig);
+        });
+    });
+    describe('loadYaml', () => {
+        it('should parse yaml content', async () => {
+            // Dynamic import to bypass potential mocking issues if we used static import earlier
+            // or just verify if exported
+            const { loadYaml } = await import('../../../src/utils/config.js');
+            const content = 'foo: bar';
+            const result = loadYaml('file.yml', content);
+            expect(result).toEqual({ foo: 'bar' });
+        });
+    });
+});

package/test/unit/utils/logger.test.ts

@@ -0,0 +1,27 @@
+import { describe, it, expect } from 'vitest';
+import { logger, setDebugMode } from '../../../src/utils/logger.js';
+import { LogLevels } from 'consola';
+
+describe('Logger', () => {
+    it('should be defined', () => {
+        expect(logger).toBeDefined();
+    });
+
+    it('should have standard methods', () => {
+        expect(typeof logger.info).toBe('function');
+        expect(typeof logger.success).toBe('function');
+        expect(typeof logger.warn).toBe('function');
+        expect(typeof logger.error).toBe('function');
+    });
+
+    it('should allows toggling debug mode', () => {
+        // Default is info (3)
+        expect(logger.level).toBe(LogLevels.info);
+
+        setDebugMode(true);
+        expect(logger.level).toBe(LogLevels.debug);
+
+        setDebugMode(false);
+        expect(logger.level).toBe(LogLevels.info);
+    });
+});

package/test/unit/utils/shell.test.ts

@@ -0,0 +1,81 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { runCommand } from '../../../src/utils/shell.js';
+import { logger } from '../../../src/utils/logger.js';
+import * as cp from 'node:child_process';
+
+vi.mock('../../../src/utils/logger.js');
+vi.mock('node:child_process', async () => {
+    return {
+        exec: vi.fn(),
+    };
+});
+
+describe('shell utils', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+
+    it('should execute command successfully', async () => {
+        const mockExec = vi.mocked(cp.exec);
+        mockExec.mockImplementation(((cmd: string, options: any, cb: any) => {
+            const callback = cb || options;
+            callback(null, { stdout: 'stdout output', stderr: '' }); // exec result is an object with stdout/stderr
+            return {} as any;
+        }) as any);
+
+        const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+
+        await runCommand('ls -la');
+
+        expect(mockExec).toHaveBeenCalledWith('ls -la', expect.anything(), expect.anything());
+        expect(consoleSpy).toHaveBeenCalledWith('stdout output');
+    });
+
+    it('should pass cwd to exec', async () => {
+        const mockExec = vi.mocked(cp.exec);
+        mockExec.mockImplementation(((cmd: string, options: any, cb: any) => {
+            const callback = cb || options;
+            callback(null, 'stdout', '');
+            return {} as any;
+        }) as any);
+
+        await runCommand('ls', '/tmp');
+
+        expect(mockExec).toHaveBeenCalledWith('ls', expect.objectContaining({ cwd: '/tmp' }), expect.anything());
+    });
+
+    it('should handle execution errors', async () => {
+        const error: any = new Error('Shell Error');
+        error.code = 1;
+
+        const mockExec = vi.mocked(cp.exec);
+        mockExec.mockImplementation(((cmd: string, options: any, cb: any) => {
+            const callback = cb || options;
+            callback(error, '', 'stderr output');
+            return {} as any;
+        }) as any);
+
+        await expect(runCommand('fail')).rejects.toThrow('Command failed: fail');
+
+        expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('Command failed'));
+    });
+
+    it('should log stderr if available on error', async () => {
+        const error: any = new Error('Shell Error');
+        error.stderr = 'Some serious shell error';
+
+        const mockExec = vi.mocked(cp.exec);
+        mockExec.mockImplementation(((cmd: string, options: any, cb: any) => {
+            const callback = cb || options;
+            callback(error, '', 'stderr output');
+            return {} as any;
+        }) as any);
+
+        await expect(runCommand('fail')).rejects.toThrow();
+        expect(logger.error).toHaveBeenCalledWith('Some serious shell error');
+    });
+});

package/test/utils/integration-helpers.ts

@@ -0,0 +1,22 @@
+import path from 'node:path';
+import { execa } from 'execa';
+import { fileURLToPath } from 'node:url';
+
+// Constants
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export const CLI_BIN = path.resolve(__dirname, '../../dist/index.js');
+
+/**
+ * Runs the CLI command against the compiled binary (E2E style)
+ */
+export async function runCLI(args: string[], cwd: string, options: any = {}) {
+    return execa('node', [CLI_BIN, ...args], {
+        cwd,
+        ...options,
+        env: {
+            ...process.env,
+            ...options.env
+        },
+        reject: false // Allow checking exit code in tests
+    });
+}

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "ESNext",
+        "moduleResolution": "Bundler",
+        "lib": [
+            "ESNext"
+        ],
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "resolveJsonModule": true,
+        "outDir": "./dist"
+    },
+    "include": [
+        "src/**/*",
+        "test/**/*",
+        "../utils/environment.ts"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist"
+    ]
+}

package/tsup.config.ts

@@ -0,0 +1,18 @@
+import type { Options } from 'tsup';
+
+export default <Options>{
+    entry: ['index.ts', 'src/**/*.ts'],
+    format: ['esm'],
+    target: 'node18',
+    clean: true,
+    bundle: true,
+    sourcemap: true,
+    dts: true,
+    minify: false,
+    splitting: true,
+    outDir: 'dist',
+    shims: true, // Enable shims (including __require shim for legacy deps)
+    banner: {
+        js: 'import { createRequire } from "module"; const require = createRequire(import.meta.url);'
+    },
+};

package/vitest.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: 'node',
+        include: ['test/unit/**/*.test.ts'],
+        coverage: {
+            provider: 'v8',
+            reporter: ['text', 'json', 'html'],
+            include: ['src/**/*.ts'],
+            exclude: ['index.ts', 'src/CommandInterface.ts', '**/*.d.ts'], // Exclude entry points that are hard to test in unit tests
+        },
+    },
+});

package/vitest.e2e.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: 'node',
+        include: ['test/e2e/**/*.test.ts'],
+        testTimeout: 60000,
+    },
+});

package/vitest.integration.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: 'node',
+        include: ['test/integration/**/*.test.ts'],
+        // Increase timeout for integration tests as they do real IO
+        testTimeout: 60000,
+        fileParallelism: false,
+        coverage: {
+            provider: 'v8',
+            reporter: ['text', 'json', 'html'],
+            include: ['src/**/*.ts'],
+        },
+    },
+});