@nexical/cli 0.1.7 → 0.11.0

package/src/utils/git.ts

@@ -0,0 +1,65 @@
+import { logger, runCommand } from '@nexical/cli-core';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execAsync = promisify(exec);
+
+export async function clone(url: string, destination: string, options: { recursive?: boolean; depth?: number } = {}): Promise<void> {
+    const { recursive = false, depth } = options;
+    const cmd = `git clone ${recursive ? '--recursive ' : ''}${depth ? `--depth ${depth} ` : ''}${url} .`;
+    logger.debug(`Git clone: ${url} to ${destination}`);
+    await runCommand(cmd, destination);
+}
+
+export async function getRemoteUrl(cwd: string, remote = 'origin'): Promise<string> {
+    try {
+        const { stdout } = await execAsync(`git remote get-url ${remote}`, { cwd });
+        return stdout.trim();
+    } catch (e) {
+        console.error('getRemoteUrl failed:', e);
+        return '';
+    }
+}
+
+export async function updateSubmodules(cwd: string): Promise<void> {
+    logger.debug(`Updating submodules in ${cwd}`);
+    await runCommand('git submodule foreach --recursive "git checkout main && git pull origin main"', cwd);
+}
+
+export async function checkoutOrphan(branch: string, cwd: string): Promise<void> {
+    await runCommand(`git checkout --orphan ${branch}`, cwd);
+}
+
+export async function addAll(cwd: string): Promise<void> {
+    await runCommand('git add -A', cwd);
+}
+
+export async function commit(message: string, cwd: string): Promise<void> {
+    // Escape quotes in message if needed, for now assuming simple messages
+    await runCommand(`git commit -m "${message}"`, cwd);
+}
+
+export async function deleteBranch(branch: string, cwd: string): Promise<void> {
+    await runCommand(`git branch -D ${branch}`, cwd);
+}
+
+export async function renameBranch(branch: string, cwd: string): Promise<void> {
+    await runCommand(`git branch -m ${branch}`, cwd);
+}
+
+export async function removeRemote(remote: string, cwd: string): Promise<void> {
+    await runCommand(`git remote remove ${remote}`, cwd);
+}
+
+export async function renameRemote(oldName: string, newName: string, cwd: string): Promise<void> {
+    await runCommand(`git remote rename ${oldName} ${newName}`, cwd);
+}
+
+export async function branchExists(branch: string, cwd: string): Promise<boolean> {
+    try {
+        await execAsync(`git show-ref --verify --quiet refs/heads/${branch}`, { cwd });
+        return true;
+    } catch {
+        return false;
+    }
+}

package/src/utils/url-resolver.ts

@@ -0,0 +1,57 @@
+/**
+ * Resolves a git URL from various shorthand formats.
+ * 
+ * Supported formats:
+ * - gh@org/repo -> https://github.com/org/repo.git
+ * - gh@org/repo//path -> https://github.com/org/repo.git//path
+ * - https://github.com/org/repo -> https://github.com/org/repo.git
+ * - https://github.com/org/repo.git -> https://github.com/org/repo.git
+ * 
+ * @param url The URL string to resolve
+ * @returns The fully qualified git URL with .git extension
+ */
+export function resolveGitUrl(url: string): string {
+    if (!url) {
+        throw new Error('URL cannot be empty');
+    }
+
+    let resolved = url;
+
+    // Handle gh@ syntax
+    if (resolved.startsWith('gh@')) {
+        resolved = resolved.replace(/^gh@/, 'https://github.com/');
+    }
+
+    // Handle subpaths (split by //)
+    // We must be careful not to split the protocol (e.g. https://)
+    const protocolMatch = resolved.match(/^[a-z0-9]+:\/\//i);
+    let splitIndex = -1;
+
+    if (protocolMatch) {
+        splitIndex = resolved.indexOf('//', protocolMatch[0].length);
+    } else {
+        splitIndex = resolved.indexOf('//');
+    }
+
+    let repoUrl = resolved;
+    let subPath = '';
+
+    if (splitIndex !== -1) {
+        repoUrl = resolved.substring(0, splitIndex);
+        subPath = resolved.substring(splitIndex + 2);
+    }
+
+    // Ensure .git extension, but ONLY for remote URLs (not local paths)
+    const isLocal = repoUrl.startsWith('/') || repoUrl.startsWith('./') || repoUrl.startsWith('../') || repoUrl.startsWith('file:') || repoUrl.startsWith('~');
+
+    if (!isLocal && !repoUrl.endsWith('.git')) {
+        repoUrl += '.git';
+    }
+
+    // Reconstruction
+    if (subPath) {
+        return `${repoUrl}//${subPath}`;
+    }
+
+    return repoUrl;
+}

package/test/e2e/lifecycle.e2e.test.ts

@@ -0,0 +1,153 @@
+import { describe, it, expect, beforeEach, afterAll } from 'vitest';
+import { createTempDir, createMockRepo, runCLI } from '../utils/integration-helpers.js';
+import path from 'node:path';
+import fs from 'fs-extra';
+import { execa } from 'execa';
+
+describe('CLI Lifecycle E2E', () => {
+    let testRoot: string;
+    let starterDir: string;
+    let moduleDir: string;
+    let mockAstroDir: string;
+
+    beforeEach(async () => {
+        testRoot = await createTempDir('e2e-life-');
+
+        // 1. Setup Mock "Astro" package
+        // We create a local package that impersonates 'astro'.
+        // This avoids npm install downloading the internet.
+        mockAstroDir = path.join(testRoot, 'mock-astro');
+        await fs.ensureDir(mockAstroDir);
+        await fs.outputFile(path.join(mockAstroDir, 'package.json'), JSON.stringify({
+            name: 'astro',
+            version: '1.0.0',
+            bin: {
+                astro: './bin.js'
+            }
+        }));
+        // The mock binary acts as "npx astro"
+        await fs.outputFile(path.join(mockAstroDir, 'bin.js'), `#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const args = process.argv.slice(2);
+console.log("MOCK_ASTRO_EXECUTED " + args.join(' '));
+
+if (args[0] === 'build') {
+    const dist = path.join(process.cwd(), 'dist');
+    if (!fs.existsSync(dist)) fs.mkdirSync(dist, { recursive: true });
+    fs.writeFileSync(path.join(dist, 'index.html'), '<html></html>');
+}
+`);
+        await fs.chmod(path.join(mockAstroDir, 'bin.js'), '755');
+
+        // 2. Setup Mock Starter Repo
+        starterDir = path.join(testRoot, 'starter-repo');
+        // We need a package.json that points 'astro' to our mock
+        await createMockRepo(starterDir, {
+            'package.json': JSON.stringify({
+                name: 'e2e-project',
+                version: '0.0.0',
+                dependencies: {
+                    // Use file: protocol to point to local mock
+                    'astro': `file:${mockAstroDir}`
+                },
+                scripts: {
+                    'build': 'astro build',
+                    'dev': 'astro dev',
+                    'preview': 'astro preview',
+                    'setup': 'echo setup'
+                }
+            }),
+            'README.md': '# E2E Starter',
+            'nexical.yml': 'name: e2e-test\nversion: 0.0.1', // ESSENTIAL for CLI to recognize project
+            'src/pages/index.astro': '--- ---',
+            'src/core/index.ts': '// core',
+            'src/core/package.json': JSON.stringify({
+                scripts: {
+                    'build': 'astro build',
+                    'dev': 'astro dev',
+                    'preview': 'astro preview'
+                }
+            })
+        });
+
+        // 3. Setup Mock Module Repo
+        moduleDir = path.join(testRoot, 'module-repo');
+        await createMockRepo(moduleDir, {
+            'package.json': JSON.stringify({ name: 'my-module', version: '0.1.0' }),
+            'module.yaml': 'name: my-test-module\nversion: 0.1.0', // Name matches E2E expectation
+            'index.ts': 'console.log("module")'
+        });
+    });
+
+    afterAll(async () => {
+        if (testRoot) await fs.remove(testRoot);
+    });
+
+    it('should complete a full project lifecycle', async () => {
+        const projectDir = path.join(testRoot, 'my-project');
+
+        const env = {
+            // Essential for git inside init/module commands
+            GIT_AUTHOR_NAME: 'Test User',
+            GIT_AUTHOR_EMAIL: 'test@example.com',
+            GIT_COMMITTER_NAME: 'Test User',
+            GIT_COMMITTER_EMAIL: 'test@example.com',
+            GIT_ALLOW_PROTOCOL: 'file'
+            // DEBUG: 'true' - Removed to reduce noise
+        };
+
+        // --- STEP 1: INIT ---
+        // Run: nexical init my-project --repo <starter>
+        const initResult = await runCLI([
+            'init',
+            'my-project',
+            '--repo', starterDir
+        ], testRoot, { env });
+
+        // 4. Check git initialization (preserved history)
+        const { stdout: log } = await execa('git', ['log', '--oneline'], { cwd: projectDir });
+        const lines = log.split('\n').filter(Boolean);
+        expect(lines.length).toBeGreaterThanOrEqual(2);
+        expect(lines[0]).toContain('Initial site commit');
+
+        // --- STEP 2: MODULE ADD ---
+        // Run: nexical module add <module>
+        const modResult = await runCLI([
+            'module',
+            'add',
+            moduleDir,
+            'my-test-module' // Explicit name
+        ], projectDir, { env });
+
+        if (modResult.exitCode !== 0) {
+            console.error('Module Add Failed:', modResult.stderr || modResult.stdout);
+        }
+        expect(modResult.exitCode).toBe(0);
+        expect(fs.existsSync(path.join(projectDir, 'modules/my-test-module'))).toBe(true);
+
+        // --- STEP 3: BUILD ---
+        // Run: nexical run build
+        // Should trigger our mock astro binary
+        const buildResult = await runCLI(['run', 'build'], projectDir, { env });
+
+        if (buildResult.exitCode !== 0) {
+            console.log(buildResult.stderr || buildResult.stdout);
+        }
+
+        expect(buildResult.exitCode).toBe(0);
+        expect(buildResult.stdout).toContain('MOCK_ASTRO_EXECUTED build');
+
+        // --- STEP 4: PREVIEW ---
+        // Run: nexical run preview
+        const previewResult = await runCLI(['run', 'preview'], projectDir, { env });
+
+        expect(previewResult.exitCode).toBe(0);
+        expect(previewResult.stdout).toContain('MOCK_ASTRO_EXECUTED preview');
+
+        // --- STEP 5: CLEAN ---
+        // Clean is now handled by manual file operations or external scripts,
+        // it's no longer a top-level command.
+
+    }, 120000); // Long timeout for full chain
+});

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

@@ -0,0 +1,85 @@
+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',
+                scripts: {
+                    setup: 'echo setup'
+                },
+                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);
+});