kitstore-cli 1.0.0

package/src/__tests__/commands/upload.test.ts

@@ -0,0 +1,404 @@
+import { uploadCommand } from '../../commands/upload';
+import * as config from '../../config';
+import axios from 'axios';
+import * as fs from 'fs-extra';
+import FormData from '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 as jest.MockedFunction<typeof config.getConfig>;
+  const mockAxiosPost = axios.post as jest.MockedFunction<typeof axios.post>;
+  const mockFsPathExists = fs.pathExists as jest.MockedFunction<any>;
+  const mockFsStat = (fs.stat as jest.MockedFunction<any>);
+  const mockFsCreateReadStream = fs.createReadStream as jest.MockedFunction<any>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.spyOn(console, 'log').mockImplementation();
+    jest.spyOn(console, 'error').mockImplementation();
+    jest.spyOn(process, 'exit').mockImplementation((code?: string | number | null | undefined) => {
+      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({} as any);
+
+      const mockFormData = {
+        append: jest.fn(),
+        getHeaders: jest.fn().mockReturnValue({ 'content-type': 'multipart/form-data' }),
+      };
+      (FormData as any).mockImplementation(() => mockFormData);
+
+      mockAxiosPost.mockResolvedValue({
+        data: {
+          id: 'rule-id',
+          name: 'test.md',
+          tag: 'test',
+          type: 'rule',
+          version: '1.0.0',
+        },
+      });
+
+      await 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(
+        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(
+        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(
+        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 } as any);
+      mockAxiosPost.mockRejectedValue({
+        response: {
+          status: 413,
+          data: { error: 'File too large' },
+        },
+      });
+
+      await expect(
+        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 } as any);
+      mockAxiosPost.mockRejectedValue({
+        response: {
+          status: 401,
+          data: { error: 'Invalid token' },
+        },
+      });
+
+      await expect(
+        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 } as any);
+      mockAxiosPost.mockRejectedValue(new Error('Network connection failed'));
+
+      await expect(
+        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 } as any);
+      mockAxiosPost.mockResolvedValue({
+        data: {
+          id: 'uploaded-rule-id',
+          name: 'Test Rule',
+          tag: 'test',
+          type: 'rule',
+          version: '1.0.0',
+        },
+      });
+
+      await 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] as any;
+      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 } as any);
+      mockAxiosPost.mockResolvedValue({
+        data: {
+          id: 'uploaded-rule-id',
+          name: 'Test Rule',
+          version: '1.0.0',
+        },
+      });
+
+      await uploadCommand('./test.md', {
+        name: 'Test Rule',
+        tag: 'test',
+        type: 'rule',
+      });
+
+      const formDataCall = mockAxiosPost.mock.calls[0][1] as any;
+      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 } as any);
+
+      // Missing tag
+      await expect(
+        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 } as any);
+      mockAxiosPost.mockResolvedValue({
+        data: {
+          id: 'uploaded-rule-id',
+          name: 'Comprehensive Rule',
+          tag: 'comprehensive',
+          type: 'rule',
+          version: '3.0.0',
+        },
+      });
+
+      await 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');
+    });
+  });
+});
+

package/src/__tests__/config.test.ts

@@ -0,0 +1,181 @@
+import { jest } from '@jest/globals';
+import { getConfig, saveConfig, getInstallPaths, Config } from '../config';
+
+// Mock dependencies
+jest.mock('fs-extra');
+jest.mock('os', () => ({
+  homedir: jest.fn().mockReturnValue('C:\\Users\\trieu'),
+}));
+
+import * as fs from 'fs-extra';
+import * as os from 'os';
+import * as path from 'path';
+
+describe('Config', () => {
+  const mockHomeDir = 'C:\\Users\\trieu';
+  const mockConfigDir = path.join(mockHomeDir, '.kitstore');
+  const mockConfigFile = path.join(mockConfigDir, 'config.json');
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Setup default mocks
+    // @ts-ignore - Jest mock types are complex
+    os.homedir.mockReturnValue(mockHomeDir);
+    // @ts-ignore
+    fs.ensureDir.mockResolvedValue(undefined);
+    // @ts-ignore
+    fs.pathExists.mockResolvedValue(false);
+    // @ts-ignore
+    fs.writeJson.mockResolvedValue(undefined);
+    // @ts-ignore
+    fs.existsSync.mockReturnValue(false);
+  });
+
+  describe('getConfig', () => {
+    it('should return default config when config file does not exist', async () => {
+      // @ts-ignore
+      (fs.pathExists as jest.Mock).mockResolvedValue(false);
+
+      const result = await getConfig();
+
+      expect(result).toEqual({
+        server: 'http://localhost:3000'
+      });
+      expect(fs.ensureDir).toHaveBeenCalledWith(mockConfigDir);
+      expect(fs.pathExists).toHaveBeenCalledWith(mockConfigFile);
+    });
+
+    it('should load and merge config from file', async () => {
+      const fileConfig = {
+        token: 'test-token',
+        server: 'https://api.example.com',
+        user: { id: '123', username: 'testuser' }
+      };
+
+      // @ts-ignore
+      fs.pathExists.mockResolvedValue(true);
+      // @ts-ignore
+      fs.readJson.mockResolvedValue(fileConfig);
+
+      const result = await getConfig();
+
+      expect(result).toEqual({
+        server: 'https://api.example.com', // From file
+        token: 'test-token',
+        user: { id: '123', username: 'testuser' }
+      });
+      expect(fs.readJson).toHaveBeenCalledWith(mockConfigFile);
+    });
+
+    it('should handle file read errors gracefully', async () => {
+      // @ts-ignore
+      fs.pathExists.mockResolvedValue(true);
+      // @ts-ignore
+      fs.readJson.mockRejectedValue(new Error('Read failed'));
+
+      const result = await getConfig();
+
+      expect(result).toEqual({
+        server: 'http://localhost:3000'
+      });
+    });
+
+    it('should handle ensureDir errors gracefully', async () => {
+      // @ts-ignore
+      fs.ensureDir.mockRejectedValue(new Error('Permission denied'));
+
+      const result = await getConfig();
+
+      expect(result).toEqual({
+        server: 'http://localhost:3000'
+      });
+    });
+  });
+
+  describe('saveConfig', () => {
+    it('should save config to file', async () => {
+      const config: Config = {
+        token: 'new-token',
+        server: 'https://new-server.com',
+        user: { id: '456', username: 'newuser' }
+      };
+
+      await saveConfig(config);
+
+      expect(fs.ensureDir).toHaveBeenCalledWith(mockConfigDir);
+      expect(fs.writeJson).toHaveBeenCalledWith(
+        mockConfigFile,
+        config,
+        { spaces: 2 }
+      );
+    });
+
+    it('should handle write errors', async () => {
+      const config: Config = { server: 'http://localhost:3000' };
+      // @ts-ignore
+      (fs.writeJson as jest.Mock).mockRejectedValue(new Error('Write failed'));
+
+      await expect(saveConfig(config)).rejects.toThrow('Write failed');
+    });
+  });
+
+  describe('getInstallPaths', () => {
+    it('should return paths in current directory .cursor folder when it exists', () => {
+      // @ts-ignore
+      (fs.existsSync as jest.Mock).mockReturnValue(true);
+
+      const result = getInstallPaths();
+
+      const cwd = process.cwd();
+      expect(result).toEqual({
+        rules: path.join(cwd, '.cursor', 'rules'),
+        commands: path.join(cwd, '.cursor', 'commands')
+      });
+      expect(fs.existsSync).toHaveBeenCalledWith(path.join(cwd, '.cursor'));
+    });
+
+    it('should return home directory paths when .cursor does not exist in cwd', () => {
+      // @ts-ignore
+      (fs.existsSync as jest.Mock).mockReturnValue(false);
+
+      const result = getInstallPaths();
+
+      expect(result).toEqual({
+        rules: path.join(mockHomeDir, '.cursor', 'rules'),
+        commands: path.join(mockHomeDir, '.cursor', 'commands')
+      });
+    });
+  });
+
+  describe('Config interface', () => {
+    it('should support all config properties', () => {
+      const config: Config = {
+        token: 'jwt-token',
+        server: 'https://api.test.com',
+        user: {
+          id: 'user-123',
+          username: 'testuser',
+          email: 'test@example.com'
+        },
+        lastLogin: '2024-01-01T00:00:00Z'
+      };
+
+      expect(config.token).toBe('jwt-token');
+      expect(config.server).toBe('https://api.test.com');
+      expect(config.user?.username).toBe('testuser');
+      expect(config.lastLogin).toBe('2024-01-01T00:00:00Z');
+    });
+
+    it('should allow optional properties', () => {
+      const minimalConfig: Config = {
+        server: 'http://localhost:3000'
+      };
+
+      expect(minimalConfig.server).toBe('http://localhost:3000');
+      expect(minimalConfig.token).toBeUndefined();
+      expect(minimalConfig.user).toBeUndefined();
+      expect(minimalConfig.lastLogin).toBeUndefined();
+    });
+  });
+});

package/src/__tests__/setup.ts

@@ -0,0 +1,11 @@
+// CLI Test Setup
+// Load test environment variables
+
+if (process.env.NODE_ENV === 'test') {
+  // Set test environment variables for CLI
+  process.env.API_BASE_URL = 'http://localhost:3001/api';
+  process.env.CLI_ENV = 'test';
+}
+
+
+

package/src/api/client.ts

@@ -0,0 +1,20 @@
+import { Configuration, AuthApi, RulesApi } from './generated';
+import { getConfig } from '../config';
+
+export async function createApi(options?: { server?: string; token?: string }) {
+  const cfg = await getConfig();
+  const basePath = options?.server || cfg.server || 'http://localhost:3000';
+  const token = options?.token || cfg.token;
+
+  const configuration = new Configuration({
+    basePath,
+    accessToken: token,
+  });
+
+  return {
+    authApi: new AuthApi(configuration),
+    rulesApi: new RulesApi(configuration),
+  };
+}
+
+

package/src/api/generated/.openapi-generator/FILES

@@ -0,0 +1,17 @@
+.gitignore
+.npmignore
+api.ts
+base.ts
+common.ts
+configuration.ts
+docs/AuthApi.md
+docs/AuthResponseDto.md
+docs/AuthUserDto.md
+docs/HealthApi.md
+docs/LoginDto.md
+docs/RegisterDto.md
+docs/RuleAuthorDto.md
+docs/RuleResponseDto.md
+docs/RulesApi.md
+git_push.sh
+index.ts

package/src/api/generated/.openapi-generator/VERSION

@@ -0,0 +1 @@
+7.17.0

package/src/api/generated/.openapi-generator-ignore

@@ -0,0 +1,23 @@
+# OpenAPI Generator Ignore
+# Generated by openapi-generator https://github.com/openapitools/openapi-generator
+
+# Use this file to prevent files from being overwritten by the generator.
+# The patterns follow closely to .gitignore or .dockerignore.
+
+# As an example, the C# client generator defines ApiClient.cs.
+# You can make changes and tell OpenAPI Generator to ignore just this file by uncommenting the following line:
+#ApiClient.cs
+
+# You can match any string of characters against a directory, file or extension with a single asterisk (*):
+#foo/*/qux
+# The above matches foo/bar/qux and foo/baz/qux, but not foo/bar/baz/qux
+
+# You can recursively match patterns against a directory, file or extension with a double asterisk (**):
+#foo/**/qux
+# This matches foo/bar/qux, foo/baz/qux, and foo/bar/baz/qux
+
+# You can also negate patterns with an exclamation (!).
+# For example, you can ignore all files in a docs folder with the file extension .md:
+#docs/*.md
+# Then explicitly reverse the ignore rule for a single file:
+#!docs/README.md