@mbc-cqrs-serverless/cli 1.0.23 → 1.0.25

package/README.md

@@ -156,6 +156,64 @@ Add MBC CQRS UI common components to your project.
 mbc ui-common -p ./src/common-ui -c all
 ```
 
+### `mbc install-skills`
+
+Install Claude Code skills for MBC CQRS Serverless development.
+
+**Alias**: `skills`
+
+**Options**:
+- `-p, --project` - Install to project directory (`.claude/skills/`) instead of personal (`~/.claude/skills/`)
+- `-f, --force` - Overwrite existing skills
+- `-l, --list` - List available skills without installing
+- `-c, --check` - Check if updates are available without installing
+
+**Examples**:
+
+```bash
+# Install to personal skills directory (available in all projects)
+mbc install-skills
+
+# Install to project directory (shared with team via git)
+mbc install-skills --project
+
+# List available skills
+mbc install-skills --list
+
+# Force overwrite existing skills
+mbc install-skills --force
+
+# Check for updates
+mbc install-skills --check
+
+# Using alias
+mbc skills -p
+```
+
+**Upgrading Skills**:
+
+Skills do not auto-update. To upgrade to the latest version:
+
+```bash
+# Update CLI to latest version
+npm update -g @mbc-cqrs-serverless/cli
+
+# Check if updates are available
+mbc install-skills --check
+
+# Force reinstall to get latest version
+mbc install-skills --force
+```
+
+**Available Skills**:
+
+| Skill | Description |
+|-------|-------------|
+| `/mbc-generate` | Generate boilerplate code (modules, services, controllers, DTOs, handlers) |
+| `/mbc-review` | Review code for best practices and anti-patterns (20 patterns) |
+| `/mbc-migrate` | Guide version migrations and breaking changes |
+| `/mbc-debug` | Debug and troubleshoot common issues |
+
 ## Project Structure
 
 The CLI creates a standardized project structure optimized for CQRS:

package/dist/actions/install-skills.action.js

@@ -0,0 +1,224 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION_FILE_NAME = void 0;
+exports.getSkillsSourcePath = getSkillsSourcePath;
+exports.getPersonalSkillsPath = getPersonalSkillsPath;
+exports.getProjectSkillsPath = getProjectSkillsPath;
+exports.copySkills = copySkills;
+exports.getInstalledVersion = getInstalledVersion;
+exports.getPackageVersion = getPackageVersion;
+exports.writeVersionFile = writeVersionFile;
+exports.default = installSkillsAction;
+const fs_1 = require("fs");
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const ui_1 = require("../ui");
+/**
+ * Version file name for tracking installed skills version
+ */
+exports.VERSION_FILE_NAME = '.mbc-skills-version';
+/**
+ * Get the path to the mcp-server skills source directory
+ */
+function getSkillsSourcePath() {
+    // Try to find the mcp-server package
+    const possiblePaths = [
+        // When installed globally or locally via npm
+        path_1.default.join(__dirname, '..', '..', '..', 'mcp-server', 'skills'),
+        // When running from monorepo
+        path_1.default.join(__dirname, '..', '..', '..', '..', 'mcp-server', 'skills'),
+        // When installed via npm in node_modules
+        path_1.default.join(process.cwd(), 'node_modules', '@mbc-cqrs-serverless', 'mcp-server', 'skills'),
+    ];
+    for (const p of possiblePaths) {
+        if ((0, fs_1.existsSync)(p)) {
+            return p;
+        }
+    }
+    // Try to resolve from npm package
+    try {
+        const mcpServerPath = require.resolve('@mbc-cqrs-serverless/mcp-server');
+        return path_1.default.join(path_1.default.dirname(mcpServerPath), '..', 'skills');
+    }
+    catch {
+        // Package not found
+    }
+    throw new Error('Could not find mcp-server skills directory. Please ensure @mbc-cqrs-serverless/mcp-server is installed.');
+}
+/**
+ * Get the path to personal skills directory (~/.claude/skills/)
+ */
+function getPersonalSkillsPath() {
+    return path_1.default.join(os_1.default.homedir(), '.claude', 'skills');
+}
+/**
+ * Get the path to project skills directory (.claude/skills/)
+ */
+function getProjectSkillsPath() {
+    return path_1.default.join(process.cwd(), '.claude', 'skills');
+}
+/**
+ * Copy skills from source to destination
+ * @returns List of copied skill names
+ */
+function copySkills(sourcePath, destPath) {
+    // Create destination directory if it doesn't exist
+    if (!(0, fs_1.existsSync)(destPath)) {
+        (0, fs_1.mkdirSync)(destPath, { recursive: true });
+    }
+    // Get all skill directories
+    const entries = (0, fs_1.readdirSync)(sourcePath, { withFileTypes: true });
+    const skillDirs = entries.filter((entry) => entry.isDirectory());
+    const copiedSkills = [];
+    for (const skillDir of skillDirs) {
+        const skillSourcePath = path_1.default.join(sourcePath, skillDir.name);
+        const skillDestPath = path_1.default.join(destPath, skillDir.name);
+        (0, fs_1.cpSync)(skillSourcePath, skillDestPath, { recursive: true });
+        copiedSkills.push(skillDir.name);
+    }
+    return copiedSkills;
+}
+/**
+ * List available skills
+ */
+function listSkills(sourcePath) {
+    const entries = (0, fs_1.readdirSync)(sourcePath, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+}
+/**
+ * Get the installed version of skills from the version file
+ * @returns The installed version or null if not found
+ */
+function getInstalledVersion(destPath) {
+    const versionFilePath = path_1.default.join(destPath, exports.VERSION_FILE_NAME);
+    if (!(0, fs_1.existsSync)(versionFilePath)) {
+        return null;
+    }
+    try {
+        const version = (0, fs_1.readFileSync)(versionFilePath, 'utf-8');
+        return version.trim();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get the package version from mcp-server package.json
+ * @returns The package version or null if not found
+ */
+function getPackageVersion(sourcePath) {
+    // The package.json is one level up from the skills directory
+    const packageJsonPath = path_1.default.join(sourcePath, '..', 'package.json');
+    if (!(0, fs_1.existsSync)(packageJsonPath)) {
+        return null;
+    }
+    try {
+        const packageJson = JSON.parse((0, fs_1.readFileSync)(packageJsonPath, 'utf-8'));
+        return packageJson.version || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Write the version file to track installed skills version
+ */
+function writeVersionFile(destPath, version) {
+    const versionFilePath = path_1.default.join(destPath, exports.VERSION_FILE_NAME);
+    (0, fs_1.writeFileSync)(versionFilePath, version, 'utf-8');
+}
+/**
+ * Install Claude Code skills for MBC CQRS Serverless
+ */
+async function installSkillsAction(options, command) {
+    if (!command) {
+        throw new Error('Command is required');
+    }
+    ui_1.logger.info(`Executing command '${command.name()}'...`);
+    const { project, force, list, check } = options;
+    // Get source path
+    let sourcePath;
+    try {
+        sourcePath = getSkillsSourcePath();
+    }
+    catch (error) {
+        ui_1.logger.error(error.message);
+        throw error;
+    }
+    // Verify source exists
+    if (!(0, fs_1.existsSync)(sourcePath)) {
+        const errorMsg = `Skills source directory not found: ${sourcePath}`;
+        ui_1.logger.error(errorMsg);
+        throw new Error(errorMsg);
+    }
+    // List mode
+    if (list) {
+        const skills = listSkills(sourcePath);
+        ui_1.logger.title('skills', 'Available Claude Code Skills:');
+        skills.forEach((skill) => {
+            ui_1.logger.log(`  - ${skill}`);
+        });
+        ui_1.logger.log('');
+        ui_1.logger.info(`Total: ${skills.length} skills`);
+        return;
+    }
+    // Determine destination path
+    const destPath = project ? getProjectSkillsPath() : getPersonalSkillsPath();
+    // Check mode - compare versions without installing
+    if (check) {
+        const installedVersion = getInstalledVersion(destPath);
+        const packageVersion = getPackageVersion(sourcePath);
+        if (!installedVersion) {
+            ui_1.logger.warn('Skills are not installed.');
+            ui_1.logger.info(`Available version: ${packageVersion || 'unknown'}`);
+            ui_1.logger.info('Run `mbc install-skills` to install.');
+            return;
+        }
+        if (!packageVersion) {
+            ui_1.logger.warn('Could not determine package version.');
+            ui_1.logger.info(`Installed version: ${installedVersion}`);
+            return;
+        }
+        if (installedVersion === packageVersion) {
+            ui_1.logger.success(`Skills are up to date (${installedVersion}).`);
+        }
+        else {
+            ui_1.logger.warn(`Update available: ${installedVersion} → ${packageVersion}`);
+            ui_1.logger.info('Run `mbc install-skills --force` to update.');
+        }
+        return;
+    }
+    // Check if skills already exist
+    if ((0, fs_1.existsSync)(destPath) && !force) {
+        const existingSkills = (0, fs_1.readdirSync)(destPath, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name);
+        if (existingSkills.length > 0) {
+            ui_1.logger.warn(`Skills already exist at ${destPath}. Use --force to overwrite.`);
+        }
+    }
+    // Copy skills
+    ui_1.logger.title('install', `Installing skills to ${destPath}`);
+    const copiedSkills = copySkills(sourcePath, destPath);
+    // Write version file
+    const packageVersion = getPackageVersion(sourcePath);
+    if (packageVersion) {
+        writeVersionFile(destPath, packageVersion);
+    }
+    ui_1.logger.success(`Successfully installed ${copiedSkills.length} skills:`);
+    copiedSkills.forEach((skill) => {
+        ui_1.logger.log(`  - ${skill}`);
+    });
+    if (packageVersion) {
+        ui_1.logger.log('');
+        ui_1.logger.info(`Version: ${packageVersion}`);
+    }
+    ui_1.logger.log('');
+    ui_1.logger.info('You can now use these skills in Claude Code:');
+    copiedSkills.forEach((skill) => {
+        ui_1.logger.log(`  /${skill}`);
+    });
+}

package/dist/actions/install-skills.action.spec.js

@@ -0,0 +1,351 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const install_skills_action_1 = __importStar(require("./install-skills.action"));
+jest.mock('fs');
+jest.mock('os');
+const fs_1 = require("fs");
+const os_1 = __importDefault(require("os"));
+const mockExistsSync = fs_1.existsSync;
+const mockMkdirSync = fs_1.mkdirSync;
+const mockCpSync = fs_1.cpSync;
+const mockReaddirSync = fs_1.readdirSync;
+const mockReadFileSync = fs_1.readFileSync;
+const mockWriteFileSync = fs_1.writeFileSync;
+describe('Install Skills Action', () => {
+    const mockCommand = {
+        name: () => 'install-skills',
+        opts: () => ({}),
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        os_1.default.homedir.mockReturnValue('/home/user');
+    });
+    describe('getSkillsSourcePath', () => {
+        it('should return the path to mcp-server skills directory', () => {
+            // Use real path module, mock only existsSync to return true for skills path
+            mockExistsSync.mockReturnValue(true);
+            const sourcePath = (0, install_skills_action_1.getSkillsSourcePath)();
+            expect(sourcePath).toContain('skills');
+        });
+        it('should try multiple paths to find skills directory', () => {
+            // First call returns false, second returns true
+            mockExistsSync
+                .mockReturnValueOnce(false)
+                .mockReturnValueOnce(false)
+                .mockReturnValueOnce(true);
+            const sourcePath = (0, install_skills_action_1.getSkillsSourcePath)();
+            expect(sourcePath).toContain('skills');
+            expect(mockExistsSync).toHaveBeenCalledTimes(3);
+        });
+        it('should fallback to require.resolve when file paths not found', () => {
+            // All file paths return false, but require.resolve finds the package
+            mockExistsSync.mockReturnValue(false);
+            // In monorepo environment, require.resolve will find mcp-server
+            // This tests the fallback path (lines 62-64)
+            const sourcePath = (0, install_skills_action_1.getSkillsSourcePath)();
+            expect(sourcePath).toContain('skills');
+        });
+    });
+    describe('getPersonalSkillsPath', () => {
+        it('should return ~/.claude/skills/ path', () => {
+            const personalPath = (0, install_skills_action_1.getPersonalSkillsPath)();
+            expect(personalPath).toContain('/home/user');
+            expect(personalPath).toContain('.claude');
+            expect(personalPath).toContain('skills');
+        });
+    });
+    describe('getProjectSkillsPath', () => {
+        it('should return .claude/skills/ path in current directory', () => {
+            const projectPath = (0, install_skills_action_1.getProjectSkillsPath)();
+            expect(projectPath).toContain('.claude/skills');
+        });
+    });
+    describe('copySkills', () => {
+        const mockSourcePath = '/source/skills';
+        const mockDestPath = '/dest/skills';
+        beforeEach(() => {
+            mockReaddirSync.mockReturnValue([
+                { name: 'mbc-generate', isDirectory: () => true },
+                { name: 'mbc-review', isDirectory: () => true },
+                { name: 'mbc-migrate', isDirectory: () => true },
+                { name: 'mbc-debug', isDirectory: () => true },
+            ]);
+        });
+        it('should create destination directory if it does not exist', () => {
+            mockExistsSync.mockReturnValue(false);
+            (0, install_skills_action_1.copySkills)(mockSourcePath, mockDestPath);
+            expect(mockMkdirSync).toHaveBeenCalledWith(mockDestPath, {
+                recursive: true,
+            });
+        });
+        it('should not create destination directory if it exists', () => {
+            mockExistsSync.mockReturnValue(true);
+            (0, install_skills_action_1.copySkills)(mockSourcePath, mockDestPath);
+            expect(mockMkdirSync).not.toHaveBeenCalled();
+        });
+        it('should copy all skill directories', () => {
+            mockExistsSync.mockReturnValue(true);
+            (0, install_skills_action_1.copySkills)(mockSourcePath, mockDestPath);
+            expect(mockCpSync).toHaveBeenCalledTimes(4);
+            expect(mockCpSync).toHaveBeenCalledWith(expect.stringContaining('mbc-generate'), expect.stringContaining('mbc-generate'), { recursive: true });
+            expect(mockCpSync).toHaveBeenCalledWith(expect.stringContaining('mbc-review'), expect.stringContaining('mbc-review'), { recursive: true });
+            expect(mockCpSync).toHaveBeenCalledWith(expect.stringContaining('mbc-migrate'), expect.stringContaining('mbc-migrate'), { recursive: true });
+            expect(mockCpSync).toHaveBeenCalledWith(expect.stringContaining('mbc-debug'), expect.stringContaining('mbc-debug'), { recursive: true });
+        });
+        it('should return the list of copied skills', () => {
+            mockExistsSync.mockReturnValue(true);
+            const copiedSkills = (0, install_skills_action_1.copySkills)(mockSourcePath, mockDestPath);
+            expect(copiedSkills).toEqual([
+                'mbc-generate',
+                'mbc-review',
+                'mbc-migrate',
+                'mbc-debug',
+            ]);
+        });
+    });
+    describe('installSkillsAction', () => {
+        beforeEach(() => {
+            mockExistsSync.mockReturnValue(true);
+            mockReaddirSync.mockReturnValue([
+                { name: 'mbc-generate', isDirectory: () => true },
+                { name: 'mbc-review', isDirectory: () => true },
+                { name: 'mbc-migrate', isDirectory: () => true },
+                { name: 'mbc-debug', isDirectory: () => true },
+            ]);
+        });
+        describe('Personal installation (default)', () => {
+            it('should install skills to personal directory by default', async () => {
+                const options = {};
+                await (0, install_skills_action_1.default)(options, mockCommand);
+                expect(mockCpSync).toHaveBeenCalled();
+            });
+            it('should install to ~/.claude/skills/', async () => {
+                const options = {};
+                await (0, install_skills_action_1.default)(options, mockCommand);
+                expect(mockCpSync).toHaveBeenCalledWith(expect.any(String), expect.stringContaining('/home/user/.claude/skills'), expect.any(Object));
+            });
+        });
+        describe('Project installation (--project flag)', () => {
+            it('should install skills to project directory when --project is specified', async () => {
+                const options = { project: true };
+                await (0, install_skills_action_1.default)(options, mockCommand);
+                expect(mockCpSync).toHaveBeenCalledWith(expect.any(String), expect.stringContaining('.claude/skills'), expect.any(Object));
+            });
+        });
+        describe('Error handling', () => {
+            it('should handle missing source directory after finding path', async () => {
+                // Source path is found, but verification fails
+                mockExistsSync
+                    .mockReturnValueOnce(true) // getSkillsSourcePath finds it
+                    .mockReturnValueOnce(false); // but verification fails
+                await expect((0, install_skills_action_1.default)({}, mockCommand)).rejects.toThrow('Skills source directory not found');
+            });
+            it('should handle undefined command', async () => {
+                mockExistsSync.mockReturnValue(true);
+                await expect((0, install_skills_action_1.default)({}, undefined)).rejects.toThrow('Command is required');
+            });
+        });
+        describe('Force option', () => {
+            it('should overwrite existing skills when --force is specified', async () => {
+                const options = { force: true };
+                mockExistsSync.mockReturnValue(true);
+                await (0, install_skills_action_1.default)(options, mockCommand);
+                expect(mockCpSync).toHaveBeenCalled();
+            });
+        });
+        describe('List option', () => {
+            it('should list available skills when --list is specified', async () => {
+                const options = { list: true };
+                await (0, install_skills_action_1.default)(options, mockCommand);
+                // Should not copy when just listing
+                expect(mockCpSync).not.toHaveBeenCalled();
+            });
+        });
+    });
+    describe('Integration scenarios', () => {
+        beforeEach(() => {
+            mockExistsSync.mockReturnValue(true);
+            mockReaddirSync.mockReturnValue([
+                { name: 'mbc-generate', isDirectory: () => true },
+                { name: 'mbc-review', isDirectory: () => true },
+                { name: 'mbc-migrate', isDirectory: () => true },
+                { name: 'mbc-debug', isDirectory: () => true },
+            ]);
+        });
+        it('should handle installation to non-existent directory', async () => {
+            mockExistsSync.mockImplementation((p) => {
+                if (p.includes('mcp-server/skills'))
+                    return true;
+                return false;
+            });
+            await (0, install_skills_action_1.default)({}, mockCommand);
+            expect(mockMkdirSync).toHaveBeenCalled();
+        });
+        it('should handle multiple concurrent installations', async () => {
+            const promises = [
+                (0, install_skills_action_1.default)({}, mockCommand),
+                (0, install_skills_action_1.default)({ project: true }, mockCommand),
+            ];
+            await expect(Promise.all(promises)).resolves.not.toThrow();
+        });
+    });
+    describe('Version management', () => {
+        describe('getInstalledVersion', () => {
+            it('should return null if version file does not exist', () => {
+                mockExistsSync.mockReturnValue(false);
+                const version = (0, install_skills_action_1.getInstalledVersion)('/dest/skills');
+                expect(version).toBeNull();
+            });
+            it('should return version from version file', () => {
+                mockExistsSync.mockReturnValue(true);
+                mockReadFileSync.mockReturnValue('1.0.24');
+                const version = (0, install_skills_action_1.getInstalledVersion)('/dest/skills');
+                expect(version).toBe('1.0.24');
+            });
+            it('should trim whitespace from version', () => {
+                mockExistsSync.mockReturnValue(true);
+                mockReadFileSync.mockReturnValue('  1.0.24\n  ');
+                const version = (0, install_skills_action_1.getInstalledVersion)('/dest/skills');
+                expect(version).toBe('1.0.24');
+            });
+            it('should return null on read error', () => {
+                mockExistsSync.mockReturnValue(true);
+                mockReadFileSync.mockImplementation(() => {
+                    throw new Error('Read error');
+                });
+                const version = (0, install_skills_action_1.getInstalledVersion)('/dest/skills');
+                expect(version).toBeNull();
+            });
+        });
+        describe('getPackageVersion', () => {
+            it('should return version from package.json', () => {
+                mockExistsSync.mockReturnValue(true);
+                mockReadFileSync.mockReturnValue(JSON.stringify({ version: '1.0.25' }));
+                const version = (0, install_skills_action_1.getPackageVersion)('/source/skills');
+                expect(version).toBe('1.0.25');
+            });
+            it('should return null if package.json does not exist', () => {
+                mockExistsSync.mockReturnValue(false);
+                const version = (0, install_skills_action_1.getPackageVersion)('/source/skills');
+                expect(version).toBeNull();
+            });
+            it('should return null on parse error', () => {
+                mockExistsSync.mockReturnValue(true);
+                mockReadFileSync.mockReturnValue('invalid json');
+                const version = (0, install_skills_action_1.getPackageVersion)('/source/skills');
+                expect(version).toBeNull();
+            });
+        });
+        describe('writeVersionFile', () => {
+            it('should write version to file', () => {
+                (0, install_skills_action_1.writeVersionFile)('/dest/skills', '1.0.25');
+                expect(mockWriteFileSync).toHaveBeenCalledWith(expect.stringContaining(install_skills_action_1.VERSION_FILE_NAME), '1.0.25', 'utf-8');
+            });
+        });
+        describe('Check option', () => {
+            beforeEach(() => {
+                mockReaddirSync.mockReturnValue([
+                    { name: 'mbc-generate', isDirectory: () => true },
+                    { name: 'mbc-review', isDirectory: () => true },
+                ]);
+            });
+            it('should check for updates when --check is specified', async () => {
+                const options = { check: true };
+                mockExistsSync.mockReturnValue(true);
+                mockReadFileSync
+                    .mockReturnValueOnce('1.0.24') // installed version
+                    .mockReturnValueOnce(JSON.stringify({ version: '1.0.25' })); // package version
+                await (0, install_skills_action_1.default)(options, mockCommand);
+                // Should not copy when just checking
+                expect(mockCpSync).not.toHaveBeenCalled();
+            });
+            it('should report up-to-date when versions match', async () => {
+                const options = { check: true };
+                mockExistsSync.mockReturnValue(true);
+                mockReadFileSync
+                    .mockReturnValueOnce('1.0.25') // installed version
+                    .mockReturnValueOnce(JSON.stringify({ version: '1.0.25' })); // package version
+                await (0, install_skills_action_1.default)(options, mockCommand);
+                expect(mockCpSync).not.toHaveBeenCalled();
+            });
+            it('should report not installed when version file does not exist', async () => {
+                const options = { check: true };
+                // First call for source path check, second for version file check (false)
+                mockExistsSync.mockImplementation((p) => {
+                    if (p.includes('mcp-server/skills') || p.includes('mcp-server\\skills')) {
+                        return true;
+                    }
+                    if (p.includes(install_skills_action_1.VERSION_FILE_NAME)) {
+                        return false;
+                    }
+                    return true;
+                });
+                mockReadFileSync.mockReturnValue(JSON.stringify({ version: '1.0.25' }));
+                await (0, install_skills_action_1.default)(options, mockCommand);
+                expect(mockCpSync).not.toHaveBeenCalled();
+            });
+            it('should handle unknown package version', async () => {
+                const options = { check: true };
+                mockExistsSync.mockImplementation((p) => {
+                    // Package.json does not exist
+                    if (p.includes('package.json')) {
+                        return false;
+                    }
+                    return true;
+                });
+                mockReadFileSync.mockReturnValue('1.0.24'); // installed version only
+                await (0, install_skills_action_1.default)(options, mockCommand);
+                expect(mockCpSync).not.toHaveBeenCalled();
+            });
+        });
+        describe('Version file creation during installation', () => {
+            beforeEach(() => {
+                mockExistsSync.mockReturnValue(true);
+                mockReaddirSync.mockReturnValue([
+                    { name: 'mbc-generate', isDirectory: () => true },
+                ]);
+                mockReadFileSync.mockReturnValue(JSON.stringify({ version: '1.0.25' }));
+            });
+            it('should create version file after installation', async () => {
+                await (0, install_skills_action_1.default)({}, mockCommand);
+                expect(mockWriteFileSync).toHaveBeenCalledWith(expect.stringContaining(install_skills_action_1.VERSION_FILE_NAME), '1.0.25', 'utf-8');
+            });
+        });
+    });
+});

package/dist/actions/new.action.js

@@ -29,7 +29,7 @@ async function newAction(name = '', options, command) {
             packageVersion = `^${matchVersions.at(-1)}`; // use the patch and minor versions
         }
         else {
-            ui_1.logger.error(`The specified package version does not exist. Please chose a valid version! ${versions}`);
+            ui_1.logger.error(`The specified package version does not exist. Please choose a valid version! ${versions}`);
             return;
         }
     }

package/dist/actions/ui.action.js

@@ -16,19 +16,19 @@ async function uiAction(options, command) {
     ui_1.logger.info(`Executing command '${command.name()}' for application with options '${JSON.stringify(options)}'`);
     const { branch, auth, component, pathDir, token = '' } = options;
     if (componentOptions.findIndex((optionName) => optionName === component) === -1) {
-        ui_1.logger.error(`Please choose correct component options: ${componentOptions.join(', ')}`);
+        ui_1.logger.error(`Please choose the correct component options: ${componentOptions.join(', ')}`);
     }
     // Check command run in base src
     if (!(0, fs_1.existsSync)(path_1.default.join(process.cwd(), 'tsconfig.json'))) {
         ui_1.logger.error('Please run command in base folder');
         return;
     }
-    // Check tsconfig.json contain path @ms
+    // Check tsconfig.json contains path @ms
     const tsconfig = JSON.parse((0, fs_1.readFileSync)(path_1.default.join(process.cwd(), 'tsconfig.json'), 'utf8'));
     if (tsconfig?.compilerOptions &&
         tsconfig?.compilerOptions?.paths &&
         tsconfig?.compilerOptions?.paths.hasOwnProperty('@ms/*')) {
-        ui_1.logger.error('The project already contain mbc-cqrs-ui-common');
+        ui_1.logger.error('The project already contains mbc-cqrs-ui-common');
         return;
     }
     // Copy source

package/dist/commands/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = loadCommands;
 const generate_command_1 = require("./generate.command");
+const install_skills_command_1 = require("./install-skills.command");
 const new_command_1 = require("./new.command");
 const start_command_1 = require("./start.command");
 const ui_command_1 = require("./ui.command");
@@ -10,6 +11,7 @@ function loadCommands(program) {
     (0, start_command_1.startCommand)(program);
     (0, ui_command_1.uiCommand)(program);
     (0, generate_command_1.generateCommand)(program);
+    (0, install_skills_command_1.installSkillsCommand)(program);
     // error handling
     program.on('command:*', () => {
         console.error(`\nInvalid command: '${program.args.join(' ')}'`);

package/dist/commands/install-skills.command.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installSkillsCommand = installSkillsCommand;
+const install_skills_action_1 = __importDefault(require("../actions/install-skills.action"));
+function installSkillsCommand(program) {
+    program
+        .command('install-skills')
+        .alias('skills')
+        .description('Install Claude Code skills for MBC CQRS Serverless development')
+        .option('-p, --project', 'Install to project directory (.claude/skills/) instead of personal (~/.claude/skills/)', false)
+        .option('-f, --force', 'Overwrite existing skills', false)
+        .option('-l, --list', 'List available skills without installing', false)
+        .option('-c, --check', 'Check if updates are available without installing', false)
+        .action(install_skills_action_1.default);
+}

package/dist/commands/ui.command.js

@@ -9,7 +9,7 @@ function uiCommand(program) {
     program
         .command('ui-common')
         .alias('ui')
-        .description('add mbc-cqrs-ui-common components to your project.')
+        .description('Add mbc-cqrs-ui-common components to your project.')
         .requiredOption('-p, --pathDir <string>', 'The place of common-ui')
         .option('-b, --branch <string>', 'The branch name', 'main')
         .option('--auth <string>', 'The auth method (HTTPS - Token, SSH)', 'SSH')

package/dist/runners/abstract.runner.js

@@ -34,7 +34,7 @@ class AbstractRunner {
     }
     /**
      * @param command
-     * @returns The entire command that will be ran when calling `run(command)`.
+     * @returns The entire command that will be run when calling `run(command)`.
      */
     rawFullCommand(command) {
         const commandArgs = [...this.args, command];

package/dist/schematics/schematic.colection.js

@@ -26,12 +26,12 @@ exports.schematics = [
     {
         name: 'entity',
         alias: 'en',
-        description: 'Create a entity.',
+        description: 'Create an entity.',
     },
     {
         name: 'dto',
         alias: 'dto',
-        description: 'Create a dto.',
+        description: 'Create a DTO.',
     },
 ];
 function buildSchematicsListAsTable() {

package/dist/utils/formatting.js

@@ -4,7 +4,7 @@ exports.normalizeToKebabOrSnakeCase = normalizeToKebabOrSnakeCase;
 /**
  *
  * @param str
- * @returns formated string
+ * @returns formatted string
  * @description normalizes input to supported path and file name format.
  * Changes camelCase strings to kebab-case, replaces spaces with dash and keeps underscores.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mbc-cqrs-serverless/cli",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "description": "a CLI to get started with MBC CQRS serverless framework",
   "keywords": [
     "mbc",
@@ -58,5 +58,5 @@
     "@faker-js/faker": "^8.3.1",
     "copyfiles": "^2.4.1"
   },
-  "gitHead": "f3c0c307de80ecd61550cdcac9ac8bdc9f79269d"
+  "gitHead": "26c722916f5c8a71b5c066eca5b8db8c21dc7bcb"
 }