kitstore-cli 1.0.0

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

@@ -0,0 +1,175 @@
+"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 search_1 = require("../../commands/search");
+const config = __importStar(require("../../config"));
+// Mock dependencies
+jest.mock('../../config', () => ({
+    getConfig: jest.fn(),
+}));
+jest.mock('../../api/client', () => ({
+    createApi: jest.fn(),
+}));
+describe('Search 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('search success', () => {
+        it('should search rules by query', 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: 'Authentication Rule',
+                            tag: 'auth',
+                            type: 'rule',
+                            description: 'Handles user authentication',
+                            version: '1.0.0',
+                            author: { username: 'user1' },
+                            createdAt: '2024-01-01T00:00:00.000Z',
+                        },
+                    ],
+                }),
+            };
+            mockCreateApi.mockResolvedValue({ rulesApi: mockRulesApi });
+            await (0, search_1.searchCommand)('auth', {});
+            expect(mockCreateApi).toHaveBeenCalledWith({ server: 'http://localhost:3000' });
+            expect(mockRulesApi.rulesControllerFindAll).toHaveBeenCalledWith({
+                name: 'auth',
+            });
+            expect(console.log).toHaveBeenCalledWith('🔍 Search results for "auth":');
+        });
+        it('should apply additional filters with search query', 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: 'Validation Rule',
+                            tag: 'validation',
+                            type: 'rule',
+                            description: 'Input validation rule',
+                            version: '1.0.0',
+                            author: { username: 'user1' },
+                            createdAt: '2024-01-01T00:00:00.000Z',
+                        },
+                    ],
+                }),
+            };
+            mockCreateApi.mockResolvedValue({ rulesApi: mockRulesApi });
+            await (0, search_1.searchCommand)('validation', { type: 'rule', limit: '5' });
+            expect(mockRulesApi.rulesControllerFindAll).toHaveBeenCalledWith({
+                name: 'validation',
+                type: 'rule',
+                limit: 5,
+            });
+        });
+        it('should handle no search 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, search_1.searchCommand)('nonexistent', {});
+            expect(console.log).toHaveBeenCalledWith('🔍 No rules or commands found matching "nonexistent".');
+        });
+    });
+    describe('search failure', () => {
+        it('should exit with error when not logged in', async () => {
+            mockGetConfig.mockResolvedValue({
+                server: 'http://localhost:3000',
+                token: undefined,
+                user: undefined,
+            });
+            await expect((0, search_1.searchCommand)('test', {})).rejects.toThrow('Process exit with code 1');
+            expect(console.error).toHaveBeenCalledWith('❌ Not logged in. Please run `kitstore login` first.');
+        });
+        it('should validate query parameter', async () => {
+            mockGetConfig.mockResolvedValue({
+                server: 'http://localhost:3000',
+                token: 'test-token',
+                user: { id: 'user-id', username: 'testuser' },
+                lastLogin: new Date().toISOString(),
+            });
+            await expect((0, search_1.searchCommand)('', {})).rejects.toThrow('Process exit with code 1');
+            expect(console.error).toHaveBeenCalledWith('❌ Search query is required.');
+        });
+        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, search_1.searchCommand)('test', {})).rejects.toThrow('Process exit with code 1');
+            expect(console.error).toHaveBeenCalledWith('❌ Search failed:', expect.any(Error));
+        });
+    });
+});

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

@@ -0,0 +1,367 @@
+"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 upload_1 = require("../../commands/upload");
+const config = __importStar(require("../../config"));
+const axios_1 = __importDefault(require("axios"));
+const fs = __importStar(require("fs-extra"));
+const form_data_1 = __importDefault(require("form-data"));
+// Mock dependencies
+jest.mock('../../config', () => ({
+    getConfig: jest.fn(),
+}));
+jest.mock('axios');
+jest.mock('fs-extra', () => ({
+    pathExists: jest.fn(),
+    stat: jest.fn(),
+    createReadStream: jest.fn(),
+}));
+jest.mock('form-data', () => {
+    return jest.fn().mockImplementation(function () {
+        const data = new Map();
+        return {
+            append: jest.fn((key, value) => {
+                data.set(key, value);
+            }),
+            get: jest.fn((key) => {
+                return data.get(key);
+            }),
+            getHeaders: jest.fn(() => ({
+                'Content-Type': 'multipart/form-data',
+            })),
+        };
+    });
+});
+// TC-UNIT-CLI-004 to TC-UNIT-CLI-005
+describe('Upload Command', () => {
+    const mockGetConfig = config.getConfig;
+    const mockAxiosPost = axios_1.default.post;
+    const mockFsPathExists = fs.pathExists;
+    const mockFsStat = fs.stat;
+    const mockFsCreateReadStream = fs.createReadStream;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        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-004: Upload command (success)
+    describe('upload success', () => {
+        it('should upload file successfully', async () => {
+            mockGetConfig.mockResolvedValue({
+                server: 'http://localhost:3000',
+                token: 'test-token',
+                user: { id: 'user-id', username: 'testuser' },
+                lastLogin: new Date().toISOString(),
+            });
+            mockFsPathExists.mockResolvedValue(true);
+            mockFsStat.mockResolvedValue({ size: 1024 }); // Small file
+            mockFsCreateReadStream.mockReturnValue({});
+            const mockFormData = {
+                append: jest.fn(),
+                getHeaders: jest.fn().mockReturnValue({ 'content-type': 'multipart/form-data' }),
+            };
+            form_data_1.default.mockImplementation(() => mockFormData);
+            mockAxiosPost.mockResolvedValue({
+                data: {
+                    id: 'rule-id',
+                    name: 'test.md',
+                    tag: 'test',
+                    type: 'rule',
+                    version: '1.0.0',
+                },
+            });
+            await (0, upload_1.uploadCommand)('./test.md', {
+                name: 'Test Rule',
+                tag: 'test',
+                type: 'rule',
+                description: 'Test description',
+            });
+            expect(mockFsPathExists).toHaveBeenCalledWith('./test.md');
+            expect(mockAxiosPost).toHaveBeenCalledWith('http://localhost:3000/api/rules', expect.any(Object), expect.objectContaining({
+                headers: expect.objectContaining({
+                    Authorization: 'Bearer test-token',
+                }),
+            }));
+        });
+    });
+    // TC-UNIT-CLI-005: Upload command (file not found)
+    describe('upload failure', () => {
+        it('should handle file not found error', async () => {
+            mockGetConfig.mockResolvedValue({
+                server: 'http://localhost:3000',
+                token: 'test-token',
+                user: { id: 'user-id', username: 'testuser' },
+                lastLogin: new Date().toISOString(),
+            });
+            mockFsPathExists.mockResolvedValue(false);
+            await expect((0, upload_1.uploadCommand)('./nonexistent.md', {
+                name: 'Test Rule',
+                tag: 'test',
+                type: 'rule',
+            })).rejects.toThrow();
+            expect(mockAxiosPost).not.toHaveBeenCalled();
+        });
+        // TC-UNIT-CLI-033: Upload with file size validation
+        it('should validate file size limits', async () => {
+            mockGetConfig.mockResolvedValue({
+                server: 'http://localhost:3000',
+                token: 'test-token',
+                user: { id: 'user-id', username: 'testuser' },
+                lastLogin: new Date().toISOString(),
+            });
+            // Mock a large file (20MB)
+            mockFsPathExists.mockResolvedValue(true);
+            mockFsStat.mockResolvedValue({ size: 20 * 1024 * 1024 }); // 20MB
+            await expect((0, upload_1.uploadCommand)('./large.md', {
+                name: 'Large Rule',
+                tag: 'test',
+                type: 'rule',
+            })).rejects.toThrow('Process exit with code 1');
+            expect(console.error).toHaveBeenCalledWith('❌ File size exceeds limit (20.00 MB > 10 MB)');
+            expect(mockAxiosPost).not.toHaveBeenCalled();
+        });
+        // TC-UNIT-CLI-034: Upload with file type validation
+        it('should validate file type', async () => {
+            mockGetConfig.mockResolvedValue({
+                server: 'http://localhost:3000',
+                token: 'test-token',
+                user: { id: 'user-id', username: 'testuser' },
+                lastLogin: new Date().toISOString(),
+            });
+            mockFsPathExists.mockResolvedValue(true);
+            mockFsStat.mockResolvedValue({ size: 1024 }); // Small file
+            await expect((0, upload_1.uploadCommand)('./invalid.exe', {
+                name: 'Invalid Rule',
+                tag: 'test',
+                type: 'rule',
+            })).rejects.toThrow('Process exit with code 1');
+            expect(console.error).toHaveBeenCalledWith('❌ Invalid file type. Allowed types: .md, .txt, .json, .cursorrules');
+            expect(mockAxiosPost).not.toHaveBeenCalled();
+        });
+        // TC-UNIT-CLI-035: Upload with API failure
+        it.skip('should handle API upload failure', async () => {
+            mockGetConfig.mockResolvedValue({
+                server: 'http://localhost:3000',
+                token: 'test-token',
+                user: { id: 'user-id', username: 'testuser' },
+                lastLogin: new Date().toISOString(),
+            });
+            mockFsPathExists.mockResolvedValue(true);
+            mockFsStat.mockResolvedValue({ size: 1024 }); // Small file
+            mockFsCreateReadStream.mockReturnValue({ size: 1024 });
+            mockAxiosPost.mockRejectedValue({
+                response: {
+                    status: 413,
+                    data: { error: 'File too large' },
+                },
+            });
+            await expect((0, upload_1.uploadCommand)('./test.md', {
+                name: 'Test Rule',
+                tag: 'test',
+                type: 'rule',
+            })).rejects.toThrow('Process exit with code 1');
+            expect(console.error).toHaveBeenCalledWith('❌ Upload failed: File too large');
+        });
+        // TC-UNIT-CLI-036: Upload with authentication error
+        it.skip('should handle authentication errors', async () => {
+            mockGetConfig.mockResolvedValue({
+                server: 'http://localhost:3000',
+                token: 'invalid-token',
+                user: { id: 'user-id', username: 'testuser' },
+                lastLogin: new Date().toISOString(),
+            });
+            mockFsPathExists.mockResolvedValue(true);
+            mockFsStat.mockResolvedValue({ size: 1024 }); // Small file
+            mockFsCreateReadStream.mockReturnValue({ size: 1024 });
+            mockAxiosPost.mockRejectedValue({
+                response: {
+                    status: 401,
+                    data: { error: 'Invalid token' },
+                },
+            });
+            await expect((0, upload_1.uploadCommand)('./test.md', {
+                name: 'Test Rule',
+                tag: 'test',
+                type: 'rule',
+            })).rejects.toThrow('Process exit with code 1');
+            expect(console.error).toHaveBeenCalledWith('❌ Upload failed: Invalid token');
+        });
+        // TC-UNIT-CLI-037: Upload with network error
+        it.skip('should handle network errors', async () => {
+            mockGetConfig.mockResolvedValue({
+                server: 'http://localhost:3000',
+                token: 'test-token',
+                user: { id: 'user-id', username: 'testuser' },
+                lastLogin: new Date().toISOString(),
+            });
+            mockFsPathExists.mockResolvedValue(true);
+            mockFsStat.mockResolvedValue({ size: 1024 }); // Small file
+            mockFsCreateReadStream.mockReturnValue({ size: 1024 });
+            mockAxiosPost.mockRejectedValue(new Error('Network connection failed'));
+            await expect((0, upload_1.uploadCommand)('./test.md', {
+                name: 'Test Rule',
+                tag: 'test',
+                type: 'rule',
+            })).rejects.toThrow('Process exit with code 1');
+            expect(console.error).toHaveBeenCalledWith('❌ Upload failed:', 'Network connection failed');
+        });
+        // TC-UNIT-CLI-038: Upload with metadata extraction
+        it.skip('should extract and send metadata correctly', async () => {
+            mockGetConfig.mockResolvedValue({
+                server: 'http://localhost:3000',
+                token: 'test-token',
+                user: { id: 'user-id', username: 'testuser' },
+                lastLogin: new Date().toISOString(),
+            });
+            mockFsPathExists.mockResolvedValue(true);
+            mockFsStat.mockResolvedValue({ size: 2048 }); // Medium file
+            mockFsCreateReadStream.mockReturnValue({ size: 2048 });
+            mockAxiosPost.mockResolvedValue({
+                data: {
+                    id: 'uploaded-rule-id',
+                    name: 'Test Rule',
+                    tag: 'test',
+                    type: 'rule',
+                    version: '1.0.0',
+                },
+            });
+            await (0, upload_1.uploadCommand)('./test.md', {
+                name: 'Test Rule',
+                tag: 'test',
+                type: 'rule',
+                description: 'A comprehensive test rule',
+                version: '2.0.0',
+            });
+            expect(mockAxiosPost).toHaveBeenCalledWith('http://localhost:3000/api/rules', expect.any(Object), expect.objectContaining({
+                headers: expect.objectContaining({
+                    Authorization: 'Bearer test-token',
+                }),
+            }));
+            // Verify the FormData contains correct metadata
+            const formDataCall = mockAxiosPost.mock.calls[0][1];
+            expect(formDataCall.get('name')).toBe('Test Rule');
+            expect(formDataCall.get('tag')).toBe('test');
+            expect(formDataCall.get('type')).toBe('rule');
+            expect(formDataCall.get('description')).toBe('A comprehensive test rule');
+            expect(formDataCall.get('version')).toBe('2.0.0');
+        });
+        // TC-UNIT-CLI-039: Upload with default version
+        it.skip('should use default version when not specified', async () => {
+            mockGetConfig.mockResolvedValue({
+                server: 'http://localhost:3000',
+                token: 'test-token',
+                user: { id: 'user-id', username: 'testuser' },
+                lastLogin: new Date().toISOString(),
+            });
+            mockFsPathExists.mockResolvedValue(true);
+            mockFsStat.mockResolvedValue({ size: 1024 }); // Small file
+            mockFsCreateReadStream.mockReturnValue({ size: 1024 });
+            mockAxiosPost.mockResolvedValue({
+                data: {
+                    id: 'uploaded-rule-id',
+                    name: 'Test Rule',
+                    version: '1.0.0',
+                },
+            });
+            await (0, upload_1.uploadCommand)('./test.md', {
+                name: 'Test Rule',
+                tag: 'test',
+                type: 'rule',
+            });
+            const formDataCall = mockAxiosPost.mock.calls[0][1];
+            expect(formDataCall.get('version')).toBe('1.0.0'); // Default version
+        });
+        // TC-UNIT-CLI-040: Upload with missing required parameters
+        it.skip('should validate required parameters', async () => {
+            mockGetConfig.mockResolvedValue({
+                server: 'http://localhost:3000',
+                token: 'test-token',
+                user: { id: 'user-id', username: 'testuser' },
+                lastLogin: new Date().toISOString(),
+            });
+            mockFsPathExists.mockResolvedValue(true);
+            mockFsStat.mockResolvedValue({ size: 1024 }); // Small file
+            mockFsCreateReadStream.mockReturnValue({ size: 1024 });
+            // Missing tag
+            await expect((0, upload_1.uploadCommand)('./test.md', {
+                name: 'Test Rule',
+                type: 'rule',
+            })).rejects.toThrow('Process exit with code 1');
+            expect(console.error).toHaveBeenCalledWith('❌ Missing required parameters: tag, type');
+        });
+        // TC-UNIT-CLI-041: Upload command success with all parameters
+        it.skip('should handle successful upload with all parameters', async () => {
+            mockGetConfig.mockResolvedValue({
+                server: 'http://localhost:3000',
+                token: 'test-token',
+                user: { id: 'user-id', username: 'testuser' },
+                lastLogin: new Date().toISOString(),
+            });
+            mockFsPathExists.mockResolvedValue(true);
+            mockFsStat.mockResolvedValue({ size: 1024 }); // Small file
+            mockFsCreateReadStream.mockReturnValue({ size: 1024 });
+            mockAxiosPost.mockResolvedValue({
+                data: {
+                    id: 'uploaded-rule-id',
+                    name: 'Comprehensive Rule',
+                    tag: 'comprehensive',
+                    type: 'rule',
+                    version: '3.0.0',
+                },
+            });
+            await (0, upload_1.uploadCommand)('./comprehensive.md', {
+                name: 'Comprehensive Rule',
+                tag: 'comprehensive',
+                type: 'rule',
+                description: 'A comprehensive test rule',
+                version: '3.0.0',
+            });
+            expect(console.log).toHaveBeenCalledWith('✅ Successfully uploaded rule: Comprehensive Rule');
+            expect(console.log).toHaveBeenCalledWith('📋 Rule ID: uploaded-rule-id');
+            expect(console.log).toHaveBeenCalledWith('🏷️  Tag: comprehensive');
+            expect(console.log).toHaveBeenCalledWith('📄 Type: rule');
+            expect(console.log).toHaveBeenCalledWith('🔢 Version: 3.0.0');
+        });
+    });
+});