kitstore-cli 1.0.0

package/dist/__tests__/commands/list.test.js

@@ -0,0 +1,173 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const list_1 = require("../../commands/list");
+const config = __importStar(require("../../config"));
+// Mock dependencies
+jest.mock('../../config', () => ({
+    getConfig: jest.fn(),
+}));
+jest.mock('../../api/client', () => ({
+    createApi: jest.fn(),
+}));
+describe('List Command', () => {
+    const mockGetConfig = config.getConfig;
+    const mockCreateApi = require('../../api/client').createApi;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.spyOn(console, 'log').mockImplementation();
+        jest.spyOn(console, 'error').mockImplementation();
+        // Re-establish process.exit mock for each test
+        jest.spyOn(process, 'exit').mockImplementation((code) => {
+            throw new Error(`Process exit with code ${code}`);
+        });
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    describe('list success', () => {
+        it('should list all rules when no filters provided', async () => {
+            mockGetConfig.mockResolvedValue({
+                server: 'http://localhost:3000',
+                token: 'test-token',
+                user: { id: 'user-id', username: 'testuser' },
+                lastLogin: new Date().toISOString(),
+            });
+            const mockRulesApi = {
+                rulesControllerFindAll: jest.fn().mockResolvedValue({
+                    data: [
+                        {
+                            id: 'rule-1',
+                            name: 'Test Rule 1',
+                            tag: 'test',
+                            type: 'rule',
+                            description: 'First test rule',
+                            version: '1.0.0',
+                            author: { username: 'user1' },
+                            createdAt: '2024-01-01T00:00:00.000Z',
+                        },
+                        {
+                            id: 'rule-2',
+                            name: 'Test Rule 2',
+                            tag: 'util',
+                            type: 'command',
+                            description: 'Second test rule',
+                            version: '2.0.0',
+                            author: { username: 'user2' },
+                            createdAt: '2024-01-02T00:00:00.000Z',
+                        },
+                    ],
+                }),
+            };
+            mockCreateApi.mockResolvedValue({ rulesApi: mockRulesApi });
+            await (0, list_1.listCommand)({});
+            expect(mockCreateApi).toHaveBeenCalledWith({ server: 'http://localhost:3000' });
+            expect(mockRulesApi.rulesControllerFindAll).toHaveBeenCalledWith({});
+            expect(console.log).toHaveBeenCalledWith(expect.stringContaining('📋 Found 2 rules/commands:'));
+        });
+        it('should apply filters when provided', async () => {
+            mockGetConfig.mockResolvedValue({
+                server: 'http://localhost:3000',
+                token: 'test-token',
+                user: { id: 'user-id', username: 'testuser' },
+                lastLogin: new Date().toISOString(),
+            });
+            const mockRulesApi = {
+                rulesControllerFindAll: jest.fn().mockResolvedValue({
+                    data: [
+                        {
+                            id: 'rule-1',
+                            name: 'Filtered Rule',
+                            tag: 'test',
+                            type: 'rule',
+                            description: 'Filtered test rule',
+                            version: '1.0.0',
+                            author: { username: 'user1' },
+                            createdAt: '2024-01-01T00:00:00.000Z',
+                        },
+                    ],
+                }),
+            };
+            mockCreateApi.mockResolvedValue({ rulesApi: mockRulesApi });
+            await (0, list_1.listCommand)({ type: 'rule', tag: 'test', limit: '10' });
+            expect(mockRulesApi.rulesControllerFindAll).toHaveBeenCalledWith({
+                type: 'rule',
+                tag: 'test',
+                limit: 10,
+            });
+        });
+        it('should handle empty results', async () => {
+            mockGetConfig.mockResolvedValue({
+                server: 'http://localhost:3000',
+                token: 'test-token',
+                user: { id: 'user-id', username: 'testuser' },
+                lastLogin: new Date().toISOString(),
+            });
+            const mockRulesApi = {
+                rulesControllerFindAll: jest.fn().mockResolvedValue({
+                    data: [],
+                }),
+            };
+            mockCreateApi.mockResolvedValue({ rulesApi: mockRulesApi });
+            await (0, list_1.listCommand)({});
+            expect(console.log).toHaveBeenCalledWith(expect.stringContaining('📭 No rules or commands found.'));
+        });
+    });
+    describe('list failure', () => {
+        it('should exit with error when not logged in', async () => {
+            mockGetConfig.mockResolvedValue({
+                server: 'http://localhost:3000',
+                token: undefined,
+                user: undefined,
+            });
+            await expect((0, list_1.listCommand)({})).rejects.toThrow('Process exit with code 1');
+            expect(console.error).toHaveBeenCalledWith(expect.stringContaining('❌ Not logged in. Please run `kitstore login` first.'));
+        });
+        it('should handle API errors gracefully', async () => {
+            mockGetConfig.mockResolvedValue({
+                server: 'http://localhost:3000',
+                token: 'test-token',
+                user: { id: 'user-id', username: 'testuser' },
+                lastLogin: new Date().toISOString(),
+            });
+            const mockRulesApi = {
+                rulesControllerFindAll: jest.fn().mockRejectedValue(new Error('API Error')),
+            };
+            mockCreateApi.mockResolvedValue({ rulesApi: mockRulesApi });
+            await expect((0, list_1.listCommand)({})).rejects.toThrow('Process exit with code 1');
+            expect(console.error).toHaveBeenCalledWith(expect.stringContaining('❌ Failed to list rules:'));
+        });
+    });
+});

package/dist/__tests__/commands/login.test.js

@@ -0,0 +1,281 @@
+"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 login_1 = require("../../commands/login");
+const config = __importStar(require("../../config"));
+const apiClient = __importStar(require("../../api/client"));
+const axios_1 = __importDefault(require("axios"));
+// Mock dependencies
+jest.mock('../../config', () => ({
+    getConfig: jest.fn(),
+    saveConfig: jest.fn(),
+}));
+jest.mock('../../api/client', () => ({
+    createApi: jest.fn(),
+}));
+jest.mock('axios');
+jest.mock('inquirer', () => ({
+    prompt: jest.fn(),
+}));
+const mockInquirer = require('inquirer');
+// TC-UNIT-CLI-001 to TC-UNIT-CLI-002
+describe('Login Command', () => {
+    const mockGetConfig = config.getConfig;
+    const mockSaveConfig = config.saveConfig;
+    const mockCreateApi = apiClient.createApi;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        axios_1.default.isAxiosError.mockImplementation((err) => err?.isAxiosError === true);
+        jest.spyOn(console, 'log').mockImplementation();
+        jest.spyOn(console, 'error').mockImplementation();
+        jest.spyOn(process, 'exit').mockImplementation((code) => {
+            throw new Error(`Process exit with code ${code}`);
+        });
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    // TC-UNIT-CLI-001: Login command (success)
+    describe('login success', () => {
+        it('should login successfully and save token', async () => {
+            const mockAuthApi = {
+                authControllerLogin: jest.fn().mockResolvedValue({
+                    data: {
+                        token: 'test-token-123',
+                        user: {
+                            id: 'user-id',
+                            username: 'testuser',
+                            email: 'test@example.com',
+                        },
+                    },
+                }),
+            };
+            mockGetConfig.mockResolvedValue({
+                server: 'http://localhost:3000',
+                token: undefined,
+                user: undefined,
+                lastLogin: undefined,
+            });
+            mockCreateApi.mockResolvedValue({
+                authApi: mockAuthApi,
+                rulesApi: {},
+            });
+            await (0, login_1.loginCommand)({
+                email: 'test@example.com',
+                password: 'Password123!',
+            });
+            expect(mockCreateApi).toHaveBeenCalledWith({ server: 'http://localhost:3000' });
+            expect(mockAuthApi.authControllerLogin).toHaveBeenCalledWith({
+                email: 'test@example.com',
+                password: 'Password123!',
+            });
+            expect(mockSaveConfig).toHaveBeenCalledWith({
+                token: 'test-token-123',
+                server: 'http://localhost:3000',
+                user: {
+                    id: 'user-id',
+                    username: 'testuser',
+                    email: 'test@example.com',
+                },
+                lastLogin: expect.any(String),
+            });
+        });
+    });
+    // TC-UNIT-CLI-002: Login command (failure)
+    describe('login failure', () => {
+        it('should handle 401 error', async () => {
+            const axiosError = {
+                isAxiosError: true,
+                response: {
+                    status: 401,
+                    data: { error: 'Invalid credentials' },
+                },
+                message: 'Request failed with status code 401',
+            };
+            const mockAuthApi = {
+                authControllerLogin: jest.fn().mockRejectedValue(axiosError),
+            };
+            mockGetConfig.mockResolvedValue({
+                server: 'http://localhost:3000',
+                token: undefined,
+                user: undefined,
+                lastLogin: undefined,
+            });
+            mockCreateApi.mockResolvedValue({
+                authApi: mockAuthApi,
+                rulesApi: {},
+            });
+            await expect((0, login_1.loginCommand)({
+                email: 'test@example.com',
+                password: 'WrongPassword',
+            })).rejects.toThrow();
+            expect(mockSaveConfig).not.toHaveBeenCalled();
+        });
+        // TC-UNIT-CLI-003: Interactive login prompts
+        it('should prompt for email and password when not provided', async () => {
+            mockInquirer.prompt
+                .mockResolvedValueOnce({ email: 'prompted@example.com' })
+                .mockResolvedValueOnce({ password: 'promptedpassword' });
+            const mockAuthApi = {
+                authControllerLogin: jest.fn().mockResolvedValue({
+                    data: {
+                        token: 'test-token-123',
+                        user: {
+                            id: 'user-id',
+                            username: 'testuser',
+                            email: 'prompted@example.com',
+                        },
+                    },
+                }),
+            };
+            mockGetConfig.mockResolvedValue({
+                server: 'http://localhost:3000',
+                token: undefined,
+                user: undefined,
+                lastLogin: undefined,
+            });
+            mockCreateApi.mockResolvedValue({
+                authApi: mockAuthApi,
+                rulesApi: {},
+            });
+            await (0, login_1.loginCommand)({});
+            expect(mockInquirer.prompt).toHaveBeenCalledTimes(2);
+            expect(mockInquirer.prompt).toHaveBeenNthCalledWith(1, [
+                { type: 'input', name: 'email', message: 'Email:' }
+            ]);
+            expect(mockInquirer.prompt).toHaveBeenNthCalledWith(2, [
+                { type: 'password', name: 'password', message: 'Password:' }
+            ]);
+            expect(mockAuthApi.authControllerLogin).toHaveBeenCalledWith({
+                email: 'prompted@example.com',
+                password: 'promptedpassword',
+            });
+        });
+        // TC-UNIT-CLI-004: Empty credentials after prompts
+        it('should exit with error when email/password are empty after prompts', async () => {
+            mockInquirer.prompt
+                .mockResolvedValueOnce({ email: '' })
+                .mockResolvedValueOnce({ password: '' });
+            mockGetConfig.mockResolvedValue({
+                server: 'http://localhost:3000',
+                token: undefined,
+                user: undefined,
+                lastLogin: undefined,
+            });
+            await expect((0, login_1.loginCommand)({})).rejects.toThrow('Process exit with code 1');
+            expect(console.error).toHaveBeenCalledWith('❌ Login failed: Email and password are required');
+        });
+        // TC-UNIT-CLI-005: Login response without token
+        it('should handle login response without token', async () => {
+            const mockAuthApi = {
+                authControllerLogin: jest.fn().mockResolvedValue({
+                    data: {
+                        user: {
+                            id: 'user-id',
+                            username: 'testuser',
+                            email: 'test@example.com',
+                        },
+                    },
+                }),
+            };
+            mockGetConfig.mockResolvedValue({
+                server: 'http://localhost:3000',
+                token: undefined,
+                user: undefined,
+                lastLogin: undefined,
+            });
+            mockCreateApi.mockResolvedValue({
+                authApi: mockAuthApi,
+                rulesApi: {},
+            });
+            await expect((0, login_1.loginCommand)({ email: 'test@example.com', password: 'password123' }))
+                .rejects.toThrow('Process exit with code 1');
+            expect(console.error).toHaveBeenCalledWith('❌ Login failed');
+        });
+        // TC-UNIT-CLI-006: Other axios errors
+        it('should handle other axios errors', async () => {
+            const axiosError = {
+                isAxiosError: true,
+                response: {
+                    status: 500,
+                    data: { error: 'Internal server error' },
+                },
+                message: 'Request failed with status code 500',
+            };
+            const mockAuthApi = {
+                authControllerLogin: jest.fn().mockRejectedValue(axiosError),
+            };
+            mockGetConfig.mockResolvedValue({
+                server: 'http://localhost:3000',
+                token: undefined,
+                user: undefined,
+                lastLogin: undefined,
+            });
+            mockCreateApi.mockResolvedValue({
+                authApi: mockAuthApi,
+                rulesApi: {},
+            });
+            await expect((0, login_1.loginCommand)({
+                email: 'test@example.com',
+                password: 'Password123!',
+            })).rejects.toThrow('Process exit with code 1');
+            expect(console.error).toHaveBeenCalledWith('❌ Login failed: Internal server error');
+        });
+        // TC-UNIT-CLI-007: Non-axios errors
+        it('should handle non-axios errors', async () => {
+            const mockAuthApi = {
+                authControllerLogin: jest.fn().mockRejectedValue(new Error('Network error')),
+            };
+            mockGetConfig.mockResolvedValue({
+                server: 'http://localhost:3000',
+                token: undefined,
+                user: undefined,
+                lastLogin: undefined,
+            });
+            mockCreateApi.mockResolvedValue({
+                authApi: mockAuthApi,
+                rulesApi: {},
+            });
+            await expect((0, login_1.loginCommand)({
+                email: 'test@example.com',
+                password: 'Password123!',
+            })).rejects.toThrow('Process exit with code 1');
+            expect(console.error).toHaveBeenCalledWith('❌ Login failed: Network error');
+        });
+    });
+});

package/dist/__tests__/commands/rule-check.test.js

@@ -0,0 +1,72 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule_check_1 = require("../../commands/rule-check");
+const fs = __importStar(require("fs-extra"));
+jest.mock('fs-extra');
+describe('Rule Check Command', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.spyOn(console, 'log').mockImplementation();
+        jest.spyOn(console, 'error').mockImplementation();
+        jest.spyOn(console, 'warn').mockImplementation();
+        jest.spyOn(process, 'exit').mockImplementation((code) => {
+            throw new Error(`Process exit with code ${code}`);
+        });
+    });
+    it('should pass for a valid rule file', async () => {
+        fs.pathExists.mockResolvedValue(true);
+        fs.readFile.mockResolvedValue('@requirement TC-UNIT-001\nValid rule content');
+        await (0, rule_check_1.ruleCheckCommand)('valid-rule.md');
+        expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Rule validation passed!'));
+    });
+    it('should exit if file not found', async () => {
+        fs.pathExists.mockResolvedValue(false);
+        await expect((0, rule_check_1.ruleCheckCommand)('non-existent.md')).rejects.toThrow('Process exit with code 1');
+        expect(console.error).toHaveBeenCalledWith(expect.stringContaining('File not found'));
+    });
+    it('should warn about missing @requirement tag', async () => {
+        fs.pathExists.mockResolvedValue(true);
+        fs.readFile.mockResolvedValue('Rule without requirement tag');
+        await (0, rule_check_1.ruleCheckCommand)('no-tag.md');
+        expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('Warning: Missing @requirement tag'));
+    });
+    it('should error if file is empty', async () => {
+        fs.pathExists.mockResolvedValue(true);
+        fs.readFile.mockResolvedValue('');
+        await (0, rule_check_1.ruleCheckCommand)('empty.md');
+        expect(console.error).toHaveBeenCalledWith(expect.stringContaining('Error: File is empty'));
+    });
+});