@urugus/slack-cli 0.2.11 → 0.2.13

package/tests/utils/slack-operations/message-operations.test.ts

@@ -1,163 +0,0 @@
-import { beforeEach, describe, it, expect, vi } from 'vitest';
-import { MessageOperations } from '../../../src/utils/slack-operations/message-operations';
-import { channelResolver } from '../../../src/utils/channel-resolver';
-
-vi.mock('@slack/web-api', () => ({
-  WebClient: vi.fn().mockImplementation(() => ({
-    conversations: {
-      history: vi.fn(),
-    },
-    users: {
-      info: vi.fn(),
-    },
-    chat: {
-      postMessage: vi.fn(),
-      scheduleMessage: vi.fn(),
-      scheduledMessages: {
-        list: vi.fn(),
-      },
-    },
-  })),
-  LogLevel: {
-    ERROR: 'error',
-  },
-}));
-
-vi.mock('../../../src/utils/channel-resolver');
-
-describe('MessageOperations', () => {
-  let messageOps: MessageOperations;
-  let mockClient: any;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    messageOps = new MessageOperations('test-token');
-    mockClient = (messageOps as any).client;
-  });
-
-  describe('scheduleMessage', () => {
-    it('should call chat.scheduleMessage with post_at', async () => {
-      mockClient.chat.scheduleMessage.mockResolvedValue({
-        ok: true,
-        scheduled_message_id: 'Q123',
-      });
-
-      await messageOps.scheduleMessage('C1234567890', 'Hello', 1770855000);
-
-      expect(mockClient.chat.scheduleMessage).toHaveBeenCalledWith({
-        channel: 'C1234567890',
-        text: 'Hello',
-        post_at: 1770855000,
-      });
-    });
-  });
-
-  describe('listScheduledMessages', () => {
-    it('should call chat.scheduledMessages.list', async () => {
-      mockClient.chat.scheduledMessages.list.mockResolvedValue({
-        ok: true,
-        scheduled_messages: [
-          { id: 'Q123', channel_id: 'C123', post_at: 1770855000, date_created: 1770854400 },
-        ],
-      });
-
-      const result = await messageOps.listScheduledMessages(undefined, 20);
-
-      expect(mockClient.chat.scheduledMessages.list).toHaveBeenCalledWith({ limit: 20 });
-      expect(result).toHaveLength(1);
-    });
-  });
-
-  describe('getHistory with mentions', () => {
-    it('should fetch user info for mentioned users in message text', async () => {
-      const mockMessages = [
-        {
-          type: 'message',
-          text: 'Hello <@U123456789> can you check this?',
-          user: 'U987654321',
-          ts: '1234567890.123456',
-        },
-        {
-          type: 'message',
-          text: '<@U111111111> and <@U222222222> please review',
-          user: 'U333333333',
-          ts: '1234567891.123456',
-        },
-      ];
-
-      const mockUsersInfo = {
-        U123456789: { ok: true, user: { name: 'john.doe' } },
-        U987654321: { ok: true, user: { name: 'jane.smith' } },
-        U111111111: { ok: true, user: { name: 'alice.brown' } },
-        U222222222: { ok: true, user: { name: 'bob.wilson' } },
-        U333333333: { ok: true, user: { name: 'charlie.davis' } },
-      };
-
-      mockClient.conversations.history.mockResolvedValue({
-        ok: true,
-        messages: mockMessages,
-      });
-
-      mockClient.users.info.mockImplementation(({ user }: { user: string }) => {
-        return Promise.resolve(mockUsersInfo[user] || { ok: false });
-      });
-
-      vi.mocked(channelResolver.resolveChannelId).mockResolvedValue('C123456789');
-
-      const result = await messageOps.getHistory('test-channel', { limit: 10 });
-
-      // Verify all user IDs were fetched (both message authors and mentioned users)
-      expect(mockClient.users.info).toHaveBeenCalledTimes(5);
-      expect(mockClient.users.info).toHaveBeenCalledWith({ user: 'U987654321' });
-      expect(mockClient.users.info).toHaveBeenCalledWith({ user: 'U333333333' });
-      expect(mockClient.users.info).toHaveBeenCalledWith({ user: 'U123456789' });
-      expect(mockClient.users.info).toHaveBeenCalledWith({ user: 'U111111111' });
-      expect(mockClient.users.info).toHaveBeenCalledWith({ user: 'U222222222' });
-
-      // Verify the returned users map contains all users
-      expect(result.users.get('U123456789')).toBe('john.doe');
-      expect(result.users.get('U987654321')).toBe('jane.smith');
-      expect(result.users.get('U111111111')).toBe('alice.brown');
-      expect(result.users.get('U222222222')).toBe('bob.wilson');
-      expect(result.users.get('U333333333')).toBe('charlie.davis');
-    });
-
-    it('should handle messages with own mentions correctly', async () => {
-      const mockMessages = [
-        {
-          type: 'message',
-          text: '<@U07L5D50RAL> please check this task',
-          user: 'U123456789',
-          ts: '1234567890.123456',
-        },
-      ];
-
-      const mockUsersInfo = {
-        U123456789: { ok: true, user: { name: 'john.doe' } },
-        U07L5D50RAL: { ok: true, user: { name: 'koguchi_s' } },
-      };
-
-      mockClient.conversations.history.mockResolvedValue({
-        ok: true,
-        messages: mockMessages,
-      });
-
-      mockClient.users.info.mockImplementation(({ user }: { user: string }) => {
-        return Promise.resolve(mockUsersInfo[user] || { ok: false });
-      });
-
-      vi.mocked(channelResolver.resolveChannelId).mockResolvedValue('C123456789');
-
-      const result = await messageOps.getHistory('test-channel', { limit: 10 });
-
-      // Verify both users were fetched
-      expect(mockClient.users.info).toHaveBeenCalledTimes(2);
-      expect(mockClient.users.info).toHaveBeenCalledWith({ user: 'U123456789' });
-      expect(mockClient.users.info).toHaveBeenCalledWith({ user: 'U07L5D50RAL' });
-
-      // Verify the returned users map contains both users
-      expect(result.users.get('U123456789')).toBe('john.doe');
-      expect(result.users.get('U07L5D50RAL')).toBe('koguchi_s');
-    });
-  });
-});

package/tests/utils/token-utils.test.ts

@@ -1,33 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { maskToken } from '../../src/utils/token-utils';
-
-describe('token-utils', () => {
-  describe('maskToken', () => {
-    it('should mask short tokens completely', () => {
-      expect(maskToken('short')).toBe('****');
-      expect(maskToken('123456789')).toBe('****');
-      expect(maskToken('')).toBe('****');
-    });
-
-    it('should mask long tokens showing prefix and suffix', () => {
-      const token = 'test-1234567890-abcdefghijklmnop';
-      expect(maskToken(token)).toBe('test-****-****-mnop');
-    });
-
-    it('should handle tokens of exactly minimum length + 1', () => {
-      const token = '1234567890'; // 10 characters
-      expect(maskToken(token)).toBe('1234-****-****-7890');
-    });
-
-    it('should handle various token formats', () => {
-      expect(maskToken('test-123456789012345')).toBe('test-****-****-2345');
-      expect(maskToken('demo-2-123456789012345')).toBe('demo-****-****-2345');
-      expect(maskToken('1234567890123456789012345')).toBe('1234-****-****-2345');
-    });
-
-    it('should handle tokens with special characters', () => {
-      expect(maskToken('test-token-with-dashes')).toBe('test-****-****-shes');
-      expect(maskToken('token_with_underscores')).toBe('toke-****-****-ores');
-    });
-  });
-});

package/tests/utils/validators.test.ts

@@ -1,307 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import {
-  validateRequired,
-  validateMutuallyExclusive,
-  validateFormat,
-  validateRange,
-  validateDateFormat,
-  formatValidators,
-  createValidationHook,
-  optionValidators,
-  createOptionParser,
-} from '../../src/utils/validators';
-import { Command } from 'commander';
-
-describe('validators', () => {
-  describe('validateRequired', () => {
-    it('should return null for valid values', () => {
-      expect(validateRequired('value', 'field')).toBeNull();
-      expect(validateRequired(123, 'field')).toBeNull();
-      expect(validateRequired(true, 'field')).toBeNull();
-      expect(validateRequired(0, 'field')).toBeNull();
-      expect(validateRequired(false, 'field')).toBeNull();
-    });
-
-    it('should return error for invalid values', () => {
-      expect(validateRequired(undefined, 'field')).toBe('field is required');
-      expect(validateRequired(null, 'field')).toBe('field is required');
-      expect(validateRequired('', 'field')).toBe('field is required');
-    });
-  });
-
-  describe('validateMutuallyExclusive', () => {
-    it('should return null when exactly one option is present', () => {
-      expect(validateMutuallyExclusive({ a: 'value' }, ['a', 'b'])).toBeNull();
-      expect(validateMutuallyExclusive({ b: 'value' }, ['a', 'b'])).toBeNull();
-    });
-
-    it('should return error when multiple options are present', () => {
-      const result = validateMutuallyExclusive({ a: 'value', b: 'value' }, ['a', 'b']);
-      expect(result).toBe('Cannot use both a and b');
-    });
-
-    it('should return error when no options are present', () => {
-      const result = validateMutuallyExclusive({}, ['a', 'b']);
-      expect(result).toBe('Must specify one of: a, b');
-    });
-
-    it('should use custom error message', () => {
-      const result = validateMutuallyExclusive(
-        { a: 'value', b: 'value' },
-        ['a', 'b'],
-        'Custom error'
-      );
-      expect(result).toBe('Custom error');
-    });
-  });
-
-  describe('validateFormat', () => {
-    it('should return null for valid format', () => {
-      expect(validateFormat('123', /^\d+$/, 'error')).toBeNull();
-      expect(validateFormat('abc', /^[a-z]+$/, 'error')).toBeNull();
-    });
-
-    it('should return error for invalid format', () => {
-      expect(validateFormat('abc', /^\d+$/, 'Must be numbers')).toBe('Must be numbers');
-      expect(validateFormat('123', /^[a-z]+$/, 'Must be letters')).toBe('Must be letters');
-    });
-  });
-
-  describe('validateRange', () => {
-    it('should return null for values within range', () => {
-      expect(validateRange(5, 1, 10)).toBeNull();
-      expect(validateRange(1, 1, 10)).toBeNull();
-      expect(validateRange(10, 1, 10)).toBeNull();
-    });
-
-    it('should return error for values below minimum', () => {
-      expect(validateRange(0, 1, 10)).toBe('Value must be at least 1');
-      expect(validateRange(-5, 0, 10, 'Count')).toBe('Count must be at least 0');
-    });
-
-    it('should return error for values above maximum', () => {
-      expect(validateRange(11, 1, 10)).toBe('Value must be at most 10');
-      expect(validateRange(1001, 1, 1000, 'Limit')).toBe('Limit must be at most 1000');
-    });
-
-    it('should handle only min or only max', () => {
-      expect(validateRange(100, 50)).toBeNull();
-      expect(validateRange(100, undefined, 200)).toBeNull();
-      expect(validateRange(30, 50)).toBe('Value must be at least 50');
-      expect(validateRange(300, undefined, 200)).toBe('Value must be at most 200');
-    });
-  });
-
-  describe('validateDateFormat', () => {
-    it('should return null for valid dates', () => {
-      expect(validateDateFormat('2024-01-01')).toBeNull();
-      expect(validateDateFormat('2024-01-01 10:30:00')).toBeNull();
-      expect(validateDateFormat('January 1, 2024')).toBeNull();
-    });
-
-    it('should return error for invalid dates', () => {
-      expect(validateDateFormat('invalid')).toBe('Invalid date format');
-      expect(validateDateFormat('2024-13-01')).toBe('Invalid date format');
-      expect(validateDateFormat('')).toBe('Invalid date format');
-    });
-  });
-
-  describe('formatValidators', () => {
-    describe('threadTimestamp', () => {
-      it('should validate correct timestamp format', () => {
-        expect(formatValidators.threadTimestamp('1234567890.123456')).toBeNull();
-        expect(formatValidators.threadTimestamp('9999999999.999999')).toBeNull();
-      });
-
-      it('should reject invalid timestamp format', () => {
-        expect(formatValidators.threadTimestamp('123')).toBe('Invalid thread timestamp format');
-        expect(formatValidators.threadTimestamp('1234567890')).toBe('Invalid thread timestamp format');
-        expect(formatValidators.threadTimestamp('1234567890.12')).toBe('Invalid thread timestamp format');
-      });
-    });
-
-    describe('channelId', () => {
-      it('should validate correct channel ID format', () => {
-        expect(formatValidators.channelId('C1234567890')).toBeNull();
-        expect(formatValidators.channelId('D1234567890')).toBeNull();
-        expect(formatValidators.channelId('G1234567890')).toBeNull();
-        expect(formatValidators.channelId('C12345678901234')).toBeNull();
-      });
-
-      it('should reject invalid channel ID format', () => {
-        expect(formatValidators.channelId('A1234567890')).toBe('Invalid channel ID format');
-        expect(formatValidators.channelId('C123')).toBe('Invalid channel ID format');
-        expect(formatValidators.channelId('general')).toBe('Invalid channel ID format');
-      });
-    });
-
-    describe('outputFormat', () => {
-      it('should validate correct output formats', () => {
-        expect(formatValidators.outputFormat('table')).toBeNull();
-        expect(formatValidators.outputFormat('simple')).toBeNull();
-        expect(formatValidators.outputFormat('json')).toBeNull();
-        expect(formatValidators.outputFormat('compact')).toBeNull();
-      });
-
-      it('should reject invalid output formats', () => {
-        expect(formatValidators.outputFormat('xml')).toBe(
-          'Invalid format. Must be one of: table, simple, json, compact'
-        );
-        expect(formatValidators.outputFormat('csv')).toBe(
-          'Invalid format. Must be one of: table, simple, json, compact'
-        );
-      });
-    });
-  });
-
-  describe('createValidationHook', () => {
-    it('should call command.error when validation fails', () => {
-      const mockCommand = {
-        opts: vi.fn().mockReturnValue({ test: 'value' }),
-        error: vi.fn(),
-      } as unknown as Command;
-
-      const validation = vi.fn().mockReturnValue('Validation error');
-      const hook = createValidationHook([validation]);
-
-      hook(mockCommand);
-
-      expect(mockCommand.opts).toHaveBeenCalled();
-      expect(validation).toHaveBeenCalledWith({ test: 'value' }, mockCommand);
-      expect(mockCommand.error).toHaveBeenCalledWith('Error: Validation error');
-    });
-
-    it('should not call command.error when all validations pass', () => {
-      const mockCommand = {
-        opts: vi.fn().mockReturnValue({ test: 'value' }),
-        error: vi.fn(),
-      } as unknown as Command;
-
-      const validation1 = vi.fn().mockReturnValue(null);
-      const validation2 = vi.fn().mockReturnValue(null);
-      const hook = createValidationHook([validation1, validation2]);
-
-      hook(mockCommand);
-
-      expect(validation1).toHaveBeenCalled();
-      expect(validation2).toHaveBeenCalled();
-      expect(mockCommand.error).not.toHaveBeenCalled();
-    });
-
-    it('should stop at first validation error', () => {
-      const mockCommand = {
-        opts: vi.fn().mockReturnValue({ test: 'value' }),
-        error: vi.fn(),
-      } as unknown as Command;
-
-      const validation1 = vi.fn().mockReturnValue('First error');
-      const validation2 = vi.fn().mockReturnValue('Second error');
-      const hook = createValidationHook([validation1, validation2]);
-
-      hook(mockCommand);
-
-      expect(validation1).toHaveBeenCalled();
-      expect(validation2).not.toHaveBeenCalled();
-      expect(mockCommand.error).toHaveBeenCalledWith('Error: First error');
-    });
-  });
-
-  describe('optionValidators', () => {
-    describe('messageOrFile', () => {
-      it('should pass when message is provided', () => {
-        expect(optionValidators.messageOrFile({ message: 'text' })).toBeNull();
-      });
-
-      it('should pass when file is provided', () => {
-        expect(optionValidators.messageOrFile({ file: 'path.txt' })).toBeNull();
-      });
-
-      it('should fail when neither is provided', () => {
-        expect(optionValidators.messageOrFile({})).toBe(
-          'You must specify either --message or --file'
-        );
-      });
-
-      it('should fail when both are provided', () => {
-        expect(optionValidators.messageOrFile({ message: 'text', file: 'path.txt' })).toBe(
-          'Cannot use both --message and --file'
-        );
-      });
-    });
-
-    describe('threadTimestamp', () => {
-      it('should pass when no thread is provided', () => {
-        expect(optionValidators.threadTimestamp({})).toBeNull();
-      });
-
-      it('should validate thread format when provided', () => {
-        expect(optionValidators.threadTimestamp({ thread: '1234567890.123456' })).toBeNull();
-        expect(optionValidators.threadTimestamp({ thread: 'invalid' })).toBe(
-          'Invalid thread timestamp format'
-        );
-      });
-    });
-
-    describe('messageCount', () => {
-      it('should pass when no number is provided', () => {
-        expect(optionValidators.messageCount({})).toBeNull();
-      });
-
-      it('should validate number range when provided', () => {
-        expect(optionValidators.messageCount({ number: '50' })).toBeNull();
-        expect(optionValidators.messageCount({ number: '0' })).toBe(
-          'Message count must be at least 1'
-        );
-        expect(optionValidators.messageCount({ number: '1001' })).toBe(
-          'Message count must be at most 1000'
-        );
-        expect(optionValidators.messageCount({ number: 'abc' })).toBe(
-          'Message count must be a number'
-        );
-      });
-    });
-
-    describe('sinceDate', () => {
-      it('should pass when no date is provided', () => {
-        expect(optionValidators.sinceDate({})).toBeNull();
-      });
-
-      it('should validate date format when provided', () => {
-        expect(optionValidators.sinceDate({ since: '2024-01-01' })).toBeNull();
-        expect(optionValidators.sinceDate({ since: 'invalid' })).toBe('Invalid date format. Use YYYY-MM-DD HH:MM:SS');
-      });
-    });
-  });
-
-  describe('createOptionParser', () => {
-    it('should parse value and return it when validation passes', () => {
-      const parser = vi.fn().mockReturnValue(50);
-      const validator = vi.fn().mockReturnValue(null);
-      const optionParser = createOptionParser(parser, validator);
-
-      const result = optionParser('50', 100);
-
-      expect(parser).toHaveBeenCalledWith('50', 100);
-      expect(validator).toHaveBeenCalledWith(50);
-      expect(result).toBe(50);
-    });
-
-    it('should throw error when validation fails', () => {
-      const parser = vi.fn().mockReturnValue(50);
-      const validator = vi.fn().mockReturnValue('Validation failed');
-      const optionParser = createOptionParser(parser, validator);
-
-      expect(() => optionParser('50', 100)).toThrow('Validation failed');
-    });
-
-    it('should work without validator', () => {
-      const parser = vi.fn().mockReturnValue(50);
-      const optionParser = createOptionParser(parser);
-
-      const result = optionParser('50', 100);
-
-      expect(parser).toHaveBeenCalledWith('50', 100);
-      expect(result).toBe(50);
-    });
-  });
-});

package/tsconfig.json

@@ -1,22 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "commonjs",
-    "lib": ["ES2020"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "noImplicitAny": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "moduleResolution": "node",
-    "allowSyntheticDefaultImports": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "tests"]
-}

package/vitest.config.ts

@@ -1,27 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: 'node',
-    coverage: {
-      provider: 'v8',
-      reporter: ['text', 'json', 'html'],
-      exclude: [
-        'node_modules/',
-        'dist/',
-        '**/*.d.ts',
-        '**/*.config.*',
-        '**/mockData/**',
-        '**/tests/**',
-      ],
-    },
-    include: ['tests/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
-    testTimeout: 10000,
-  },
-  resolve: {
-    alias: {
-      '@': '/src',
-    },
-  },
-});