kitstore-cli 1.0.0

package/.env.test

@@ -0,0 +1,4 @@
+# Test environment configuration for CLI
+NODE_ENV=test
+API_BASE_URL=http://localhost:3001
+JWT_SECRET=test-secret-key-for-cli-tests-min-32-chars-long

package/.eslintrc.js

@@ -0,0 +1,29 @@
+module.exports = {
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    project: 'tsconfig.json',
+    tsconfigRootDir: __dirname,
+    sourceType: 'module',
+  },
+  plugins: ['@typescript-eslint/eslint-plugin'],
+  extends: [
+    'eslint:recommended',
+    '@typescript-eslint/recommended',
+  ],
+  root: true,
+  env: {
+    node: true,
+    jest: true,
+  },
+  ignorePatterns: ['.eslintrc.js', 'dist'],
+  rules: {
+    '@typescript-eslint/interface-name-prefix': 'off',
+    '@typescript-eslint/explicit-function-return-type': 'off',
+    '@typescript-eslint/explicit-module-boundary-types': 'off',
+    '@typescript-eslint/no-explicit-any': 'off',
+    '@typescript-eslint/no-unused-vars': ['warn', { argsIgnorePattern: '^_' }],
+  },
+};
+
+
+

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

@@ -0,0 +1,76 @@
+"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 init_1 = require("../../commands/init");
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const inquirer_1 = __importDefault(require("inquirer"));
+jest.mock('fs-extra');
+jest.mock('inquirer');
+describe('Init Command', () => {
+    const cwd = process.cwd();
+    const cursorDir = path.join(cwd, '.cursor');
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.spyOn(console, 'log').mockImplementation();
+        jest.spyOn(console, 'error').mockImplementation();
+    });
+    it('should initialize cursor kit directories', async () => {
+        fs.pathExists.mockResolvedValue(false);
+        fs.ensureDir.mockResolvedValue(undefined);
+        await (0, init_1.initCommand)();
+        expect(fs.ensureDir).toHaveBeenCalledWith(path.join(cursorDir, 'rules'));
+        expect(fs.ensureDir).toHaveBeenCalledWith(path.join(cursorDir, 'commands'));
+        expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Successfully initialized Cursor Kit!'));
+    });
+    it('should ask for confirmation if .cursor exists', async () => {
+        fs.pathExists.mockResolvedValue(true);
+        inquirer_1.default.prompt.mockResolvedValue({ overwrite: true });
+        fs.ensureDir.mockResolvedValue(undefined);
+        await (0, init_1.initCommand)();
+        expect(inquirer_1.default.prompt).toHaveBeenCalled();
+        expect(fs.ensureDir).toHaveBeenCalled();
+    });
+    it('should cancel if user chooses not to overwrite', async () => {
+        fs.pathExists.mockResolvedValue(true);
+        inquirer_1.default.prompt.mockResolvedValue({ overwrite: false });
+        await (0, init_1.initCommand)();
+        expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Initialization cancelled.'));
+        expect(fs.ensureDir).not.toHaveBeenCalled();
+    });
+});

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

@@ -0,0 +1,422 @@
+"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_1 = require("../../commands/install");
+const config = __importStar(require("../../config"));
+const apiClient = __importStar(require("../../api/client"));
+const axios_1 = __importDefault(require("axios"));
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+// Mock dependencies
+jest.mock('../../config', () => ({
+    getConfig: jest.fn(),
+    getInstallPaths: jest.fn(),
+}));
+jest.mock('../../api/client', () => ({
+    createApi: jest.fn(),
+}));
+jest.mock('axios');
+jest.mock('fs-extra', () => ({
+    pathExists: jest.fn(),
+    ensureDir: jest.fn(),
+    writeFile: jest.fn(),
+    createReadStream: jest.fn(),
+}));
+jest.mock('inquirer', () => ({
+    prompt: jest.fn(),
+}));
+// TC-UNIT-CLI-003: Install command (success)
+describe('Install Command', () => {
+    const mockGetConfig = config.getConfig;
+    const mockGetInstallPaths = config.getInstallPaths;
+    const mockCreateApi = apiClient.createApi;
+    const mockAxiosGet = axios_1.default.get;
+    const mockFsEnsureDir = fs.ensureDir;
+    const mockFsPathExists = fs.pathExists;
+    const mockFsWriteFile = fs.writeFile;
+    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();
+    });
+    it('should install rule successfully', async () => {
+        mockGetConfig.mockResolvedValue({
+            server: 'http://localhost:3000',
+            token: 'test-token',
+            user: { id: 'user-id', username: 'testuser' },
+            lastLogin: new Date().toISOString(),
+        });
+        mockGetInstallPaths.mockReturnValue({
+            rules: '/path/to/rules',
+            commands: '/path/to/commands',
+        });
+        const mockRulesApi = {
+            rulesControllerFindAll: jest.fn().mockResolvedValue({
+                data: [
+                    {
+                        id: 'rule-id-1',
+                        name: 'Test Rule',
+                        tag: 'test',
+                        type: 'rule',
+                    },
+                ],
+            }),
+            rulesControllerGetDownloadUrl: jest.fn().mockResolvedValue({
+                data: {
+                    downloadUrl: 'https://signed-url.com/file',
+                },
+            }),
+        };
+        mockCreateApi.mockResolvedValue({
+            authApi: {},
+            rulesApi: mockRulesApi,
+        });
+        mockAxiosGet.mockResolvedValue({
+            data: 'rule content',
+        });
+        mockFsPathExists.mockResolvedValue(false);
+        mockFsEnsureDir.mockResolvedValue(undefined);
+        mockFsWriteFile.mockResolvedValue(undefined);
+        // Mock inquirer when multiple rules exist
+        const mockInquirer = require('inquirer');
+        mockInquirer.prompt = jest.fn().mockResolvedValue({ rule: 'rule-id-1' });
+        await (0, install_1.installCommand)({
+            tag: 'test',
+            type: 'rule',
+        });
+        expect(mockRulesApi.rulesControllerFindAll).toHaveBeenCalled();
+        expect(mockRulesApi.rulesControllerGetDownloadUrl).toHaveBeenCalledWith('rule-id-1');
+        expect(mockAxiosGet).toHaveBeenCalledWith('https://signed-url.com/file', {
+            responseType: 'text',
+        });
+        expect(mockFsWriteFile).toHaveBeenCalled();
+    });
+    // TC-UNIT-CLI-026: Install with tag filtering
+    it('should filter rules by tag', async () => {
+        mockGetConfig.mockResolvedValue({
+            server: 'http://localhost:3000',
+            token: 'test-token',
+            user: { id: 'user-id', username: 'testuser' },
+            lastLogin: new Date().toISOString(),
+        });
+        mockGetInstallPaths.mockReturnValue({
+            rules: '/path/to/rules',
+            commands: '/path/to/commands',
+        });
+        const mockRulesApi = {
+            rulesControllerFindAll: jest.fn().mockResolvedValue({
+                data: [
+                    {
+                        id: 'rule-id-1',
+                        name: 'Test Rule',
+                        tag: 'test',
+                        type: 'rule',
+                        version: '1.0.0',
+                        author: { username: 'testuser' },
+                        description: 'A test rule',
+                    },
+                ],
+            }),
+            rulesControllerGetDownloadUrl: jest.fn().mockResolvedValue({
+                data: { downloadUrl: 'https://signed-url.com/file' },
+            }),
+        };
+        mockCreateApi.mockResolvedValue({
+            authApi: {},
+            rulesApi: mockRulesApi,
+        });
+        mockAxiosGet.mockResolvedValue({ data: 'rule content' });
+        mockFsPathExists.mockResolvedValue(false);
+        mockFsEnsureDir.mockResolvedValue(undefined);
+        mockFsWriteFile.mockResolvedValue(undefined);
+        await (0, install_1.installCommand)({ tag: 'test' });
+        expect(mockRulesApi.rulesControllerFindAll).toHaveBeenCalledWith({ tag: 'test' });
+    });
+    // TC-UNIT-CLI-027: Install with type filtering
+    it('should filter rules by type', async () => {
+        mockGetConfig.mockResolvedValue({
+            server: 'http://localhost:3000',
+            token: 'test-token',
+            user: { id: 'user-id', username: 'testuser' },
+            lastLogin: new Date().toISOString(),
+        });
+        mockGetInstallPaths.mockReturnValue({
+            rules: '/path/to/rules',
+            commands: '/path/to/commands',
+        });
+        const mockRulesApi = {
+            rulesControllerFindAll: jest.fn().mockResolvedValue({
+                data: [
+                    {
+                        id: 'rule-id-1',
+                        name: 'Test Rule',
+                        tag: 'test',
+                        type: 'rule',
+                        version: '1.0.0',
+                        author: { username: 'testuser' },
+                    },
+                ],
+            }),
+            rulesControllerGetDownloadUrl: jest.fn().mockResolvedValue({
+                data: { downloadUrl: 'https://signed-url.com/file' },
+            }),
+        };
+        mockCreateApi.mockResolvedValue({
+            authApi: {},
+            rulesApi: mockRulesApi,
+        });
+        mockAxiosGet.mockResolvedValue({ data: 'rule content' });
+        mockFsPathExists.mockResolvedValue(false);
+        mockFsEnsureDir.mockResolvedValue(undefined);
+        mockFsWriteFile.mockResolvedValue(undefined);
+        await (0, install_1.installCommand)({ type: 'rule' });
+        expect(mockRulesApi.rulesControllerFindAll).toHaveBeenCalledWith({ type: 'rule' });
+    });
+    // TC-UNIT-CLI-028: Install with file download failure
+    it('should handle file download failure', async () => {
+        mockGetConfig.mockResolvedValue({
+            server: 'http://localhost:3000',
+            token: 'test-token',
+            user: { id: 'user-id', username: 'testuser' },
+            lastLogin: new Date().toISOString(),
+        });
+        mockGetInstallPaths.mockReturnValue({
+            rules: '/path/to/rules',
+            commands: '/path/to/commands',
+        });
+        const mockRulesApi = {
+            rulesControllerFindAll: jest.fn().mockResolvedValue({
+                data: [
+                    {
+                        id: 'rule-id-1',
+                        name: 'Test Rule',
+                        tag: 'test',
+                        type: 'rule',
+                        version: '1.0.0',
+                        author: { username: 'testuser' },
+                    },
+                ],
+            }),
+            rulesControllerGetDownloadUrl: jest.fn().mockResolvedValue({
+                data: { downloadUrl: 'https://signed-url.com/file' },
+            }),
+        };
+        mockCreateApi.mockResolvedValue({
+            authApi: {},
+            rulesApi: mockRulesApi,
+        });
+        // Mock axios download failure
+        mockAxiosGet.mockRejectedValue(new Error('Download failed'));
+        mockFsPathExists.mockResolvedValue(false);
+        await expect((0, install_1.installCommand)({})).rejects.toThrow('Process exit with code 1');
+        expect(mockAxiosGet).toHaveBeenCalledWith('https://signed-url.com/file', {
+            responseType: 'text',
+        });
+        expect(console.error).toHaveBeenCalledWith('❌ Failed to download rule:', 'Download failed');
+    });
+    // TC-UNIT-CLI-029: Install with directory permission issues
+    it('should handle directory creation permission issues', async () => {
+        mockGetConfig.mockResolvedValue({
+            server: 'http://localhost:3000',
+            token: 'test-token',
+            user: { id: 'user-id', username: 'testuser' },
+            lastLogin: new Date().toISOString(),
+        });
+        mockGetInstallPaths.mockReturnValue({
+            rules: '/path/to/rules',
+            commands: '/path/to/commands',
+        });
+        const mockRulesApi = {
+            rulesControllerFindAll: jest.fn().mockResolvedValue({
+                data: [
+                    {
+                        id: 'rule-id-1',
+                        name: 'Test Rule',
+                        tag: 'test',
+                        type: 'rule',
+                        version: '1.0.0',
+                        author: { username: 'testuser' },
+                    },
+                ],
+            }),
+            rulesControllerGetDownloadUrl: jest.fn().mockResolvedValue({
+                data: { downloadUrl: 'https://signed-url.com/file' },
+            }),
+        };
+        mockCreateApi.mockResolvedValue({
+            authApi: {},
+            rulesApi: mockRulesApi,
+        });
+        mockAxiosGet.mockResolvedValue({ data: 'rule content' });
+        mockFsPathExists.mockResolvedValue(false);
+        mockFsEnsureDir.mockRejectedValue(new Error('Permission denied'));
+        mockFsWriteFile.mockResolvedValue(undefined);
+        await expect((0, install_1.installCommand)({})).rejects.toThrow('Process exit with code 1');
+        expect(mockFsEnsureDir).toHaveBeenCalledWith('/path/to/rules');
+        expect(console.error).toHaveBeenCalledWith('❌ Failed to create installation directory:', 'Permission denied');
+    });
+    // TC-UNIT-CLI-030: Install with force overwrite
+    it('should handle force overwrite option', async () => {
+        mockGetConfig.mockResolvedValue({
+            server: 'http://localhost:3000',
+            token: 'test-token',
+            user: { id: 'user-id', username: 'testuser' },
+            lastLogin: new Date().toISOString(),
+        });
+        mockGetInstallPaths.mockReturnValue({
+            rules: '/path/to/rules',
+            commands: '/path/to/commands',
+        });
+        const mockRulesApi = {
+            rulesControllerFindAll: jest.fn().mockResolvedValue({
+                data: [
+                    {
+                        id: 'rule-id-1',
+                        name: 'Test Rule',
+                        tag: 'test',
+                        type: 'rule',
+                        version: '1.0.0',
+                        author: { username: 'testuser' },
+                    },
+                ],
+            }),
+            rulesControllerGetDownloadUrl: jest.fn().mockResolvedValue({
+                data: { downloadUrl: 'https://signed-url.com/file' },
+            }),
+        };
+        mockCreateApi.mockResolvedValue({
+            authApi: {},
+            rulesApi: mockRulesApi,
+        });
+        mockAxiosGet.mockResolvedValue({ data: 'rule content' });
+        mockFsPathExists.mockResolvedValue(true); // File already exists
+        mockFsEnsureDir.mockResolvedValue(undefined);
+        mockFsWriteFile.mockResolvedValue(undefined);
+        await (0, install_1.installCommand)({ force: true });
+        expect(mockFsWriteFile).toHaveBeenCalledWith(path.join('/path/to/rules', 'rule-id-1'), 'rule content');
+        expect(console.log).toHaveBeenCalledWith('✅ Successfully installed rule: Test Rule');
+    });
+    // TC-UNIT-CLI-031: Install with no rules found
+    it('should handle no rules found', 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({
+            authApi: {},
+            rulesApi: mockRulesApi,
+        });
+        await (0, install_1.installCommand)({});
+        expect(console.log).toHaveBeenCalledWith('📭 No rules found matching the criteria.');
+    });
+    // TC-UNIT-CLI-032: Install with multiple rules (interactive selection)
+    it('should handle multiple rules with interactive selection', async () => {
+        const mockInquirer = require('inquirer');
+        mockInquirer.prompt = jest.fn().mockResolvedValue({ rule: 'rule-id-2' });
+        mockGetConfig.mockResolvedValue({
+            server: 'http://localhost:3000',
+            token: 'test-token',
+            user: { id: 'user-id', username: 'testuser' },
+            lastLogin: new Date().toISOString(),
+        });
+        mockGetInstallPaths.mockReturnValue({
+            rules: '/path/to/rules',
+            commands: '/path/to/commands',
+        });
+        const mockRulesApi = {
+            rulesControllerFindAll: jest.fn().mockResolvedValue({
+                data: [
+                    {
+                        id: 'rule-id-1',
+                        name: 'Test Rule 1',
+                        tag: 'test',
+                        type: 'rule',
+                        version: '1.0.0',
+                        author: { username: 'testuser' },
+                    },
+                    {
+                        id: 'rule-id-2',
+                        name: 'Test Rule 2',
+                        tag: 'test',
+                        type: 'rule',
+                        version: '1.0.0',
+                        author: { username: 'testuser' },
+                    },
+                ],
+            }),
+            rulesControllerGetDownloadUrl: jest.fn().mockResolvedValue({
+                data: { downloadUrl: 'https://signed-url.com/file' },
+            }),
+        };
+        mockCreateApi.mockResolvedValue({
+            authApi: {},
+            rulesApi: mockRulesApi,
+        });
+        mockAxiosGet.mockResolvedValue({ data: 'rule content' });
+        mockFsPathExists.mockResolvedValue(false);
+        mockFsEnsureDir.mockResolvedValue(undefined);
+        mockFsWriteFile.mockResolvedValue(undefined);
+        await (0, install_1.installCommand)({});
+        expect(mockInquirer.prompt).toHaveBeenCalledWith([
+            {
+                type: 'list',
+                name: 'rule',
+                message: 'Select a rule to install:',
+                choices: [
+                    { name: 'Test Rule 1 (rule-id-1)', value: 'rule-id-1' },
+                    { name: 'Test Rule 2 (rule-id-2)', value: 'rule-id-2' },
+                ],
+            },
+        ]);
+        expect(mockRulesApi.rulesControllerGetDownloadUrl).toHaveBeenCalledWith('rule-id-2');
+    });
+});