@urugus/slack-cli 0.2.7 → 0.2.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@urugus/slack-cli",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "A command-line tool for sending messages to Slack",
   "main": "dist/index.js",
   "bin": {
@@ -31,27 +31,25 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@slack/web-api": "^6.9.0",
-    "chalk": "^4.1.2",
-    "commander": "^11.1.0",
-    "dotenv": "^16.3.1",
-    "inquirer": "^8.2.6",
+    "@slack/web-api": "^7.9.3",
+    "chalk": "^5.4.1",
+    "commander": "^14.0.0",
     "p-limit": "^3.1.0"
   },
   "devDependencies": {
-    "@types/inquirer": "^8.2.10",
     "@types/node": "^20.10.0",
-    "@typescript-eslint/eslint-plugin": "^6.13.0",
-    "@typescript-eslint/parser": "^6.13.0",
-    "@vitest/coverage-v8": "^1.0.4",
-    "eslint": "^8.55.0",
-    "eslint-config-prettier": "^9.1.0",
+    "@typescript-eslint/eslint-plugin": "^8.34.1",
+    "@typescript-eslint/parser": "^8.34.1",
+    "@vitest/coverage-v8": "^3.2.4",
+    "eslint": "^9.30.0",
+    "eslint-config-prettier": "^10.1.5",
     "prettier": "^3.1.1",
     "ts-node": "^10.9.1",
     "typescript": "^5.3.2",
-    "vitest": "^1.0.4"
+    "typescript-eslint": "^8.35.0",
+    "vitest": "^3.2.4"
   },
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=20.0.0"
   }
 }

package/src/commands/history-display.ts

@@ -1,38 +1,19 @@
-import chalk from 'chalk';
 import { Message } from '../utils/slack-api-client';
-import { formatSlackTimestamp } from '../utils/date-utils';
-import { formatMessageWithMentions } from '../utils/format-utils';
+import { createHistoryFormatter } from '../utils/formatters/history-formatters';
 
 export function displayHistoryResults(
   messages: Message[],
   users: Map<string, string>,
-  channelName: string
+  channelName: string,
+  format = 'table'
 ): void {
-  if (messages.length === 0) {
-    console.log(chalk.yellow('No messages found in the specified channel.'));
-    return;
-  }
-
-  console.log(chalk.bold(`\nMessage History for #${channelName}:\n`));
-
   // Display messages in reverse order (oldest first)
-  messages.reverse().forEach((message: Message) => {
-    const timestamp = formatSlackTimestamp(message.ts);
-    let author = 'Unknown';
+  const orderedMessages = [...messages].reverse();
 
-    if (message.user && users.has(message.user)) {
-      author = users.get(message.user)!;
-    } else if (message.bot_id) {
-      author = 'Bot';
-    }
-
-    console.log(chalk.gray(`[${timestamp}]`) + ' ' + chalk.cyan(author));
-    if (message.text) {
-      const formattedText = formatMessageWithMentions(message.text, users);
-      console.log(formattedText);
-    }
-    console.log(''); // Empty line between messages
+  const formatter = createHistoryFormatter(format);
+  formatter.format({
+    channelName,
+    messages: orderedMessages,
+    users,
   });
-
-  console.log(chalk.green(`✓ Displayed ${messages.length} message(s)`));
 }

package/src/commands/history.ts

@@ -6,6 +6,7 @@ import { HistoryOptions } from '../types/commands';
 import { API_LIMITS } from '../utils/constants';
 import { parseCount, parseProfile } from '../utils/option-parsers';
 import { createValidationHook, optionValidators } from '../utils/validators';
+import { parseFormat } from '../utils/option-parsers';
 import { prepareSinceTimestamp } from './history-validators';
 import { displayHistoryResults } from './history-display';
 
@@ -19,10 +20,15 @@ export function setupHistoryCommand(): Command {
       API_LIMITS.DEFAULT_MESSAGE_COUNT.toString()
     )
     .option('--since <date>', 'Get messages since specific date (YYYY-MM-DD HH:MM:SS)')
+    .option('--format <format>', 'Output format: table, simple, json', 'table')
     .option('--profile <profile>', 'Use specific workspace profile')
     .hook(
       'preAction',
-      createValidationHook([optionValidators.messageCount, optionValidators.sinceDate])
+      createValidationHook([
+        optionValidators.messageCount,
+        optionValidators.sinceDate,
+        optionValidators.format,
+      ])
     )
     .action(
       wrapCommand(async (options: HistoryOptions) => {
@@ -46,7 +52,8 @@ export function setupHistoryCommand(): Command {
         }
 
         const { messages, users } = await client.getHistory(options.channel, historyOptions);
-        displayHistoryResults(messages, users, options.channel);
+        const format = parseFormat(options.format);
+        displayHistoryResults(messages, users, options.channel, format);
       })
     );
 

package/src/commands/unread.ts

@@ -1,7 +1,7 @@
 import { Command } from 'commander';
 import { wrapCommand } from '../utils/command-wrapper';
 import { createSlackClient } from '../utils/client-factory';
-import { SlackApiClient } from '../utils/slack-api-client';
+import { SlackApiClient, ChannelUnreadResult, Channel } from '../utils/slack-api-client';
 import { UnreadOptions } from '../types/commands';
 import chalk from 'chalk';
 import { createChannelFormatter } from '../utils/formatters/channel-formatters';
@@ -9,15 +9,15 @@ import { createMessageFormatter } from '../utils/formatters/message-formatters';
 import { DEFAULTS } from '../utils/constants';
 import { parseLimit, parseFormat, parseBoolean } from '../utils/option-parsers';
 
-async function handleSpecificChannelUnread(
-  client: SlackApiClient,
-  options: UnreadOptions
-): Promise<void> {
-  const result = await client.getChannelUnread(options.channel!);
-
-  const format = parseFormat(options.format);
-  const countOnly = parseBoolean(options.countOnly);
+async function fetchChannelUnreadData(client: SlackApiClient, channelName: string) {
+  return await client.getChannelUnread(channelName);
+}
 
+function formatChannelUnreadOutput(
+  result: ChannelUnreadResult,
+  format: string,
+  countOnly: boolean
+): void {
   const formatter = createMessageFormatter(format);
   formatter.format({
     channel: result.channel,
@@ -26,40 +26,70 @@ async function handleSpecificChannelUnread(
     countOnly: countOnly,
     format: format,
   });
+}
+
+async function markChannelAsRead(client: SlackApiClient, channel: Channel): Promise<void> {
+  await client.markAsRead(channel.id);
+  console.log(chalk.green(`✓ Marked messages in #${channel.name} as read`));
+}
+
+async function handleSpecificChannelUnread(
+  client: SlackApiClient,
+  options: UnreadOptions
+): Promise<void> {
+  const result = await fetchChannelUnreadData(client, options.channel!);
+
+  const format = parseFormat(options.format);
+  const countOnly = parseBoolean(options.countOnly);
+
+  formatChannelUnreadOutput(result, format, countOnly);
 
   if (parseBoolean(options.markRead)) {
-    await client.markAsRead(result.channel.id);
-    console.log(chalk.green(`✓ Marked messages in #${result.channel.name} as read`));
+    await markChannelAsRead(client, result.channel);
   }
 }
 
+async function fetchAllUnreadChannels(client: SlackApiClient) {
+  return await client.listUnreadChannels();
+}
+
+function formatAllChannelsOutput(
+  channels: Channel[],
+  format: string,
+  countOnly: boolean,
+  limit: number
+): void {
+  const displayChannels = channels.slice(0, limit);
+  const formatter = createChannelFormatter(format, countOnly);
+  formatter.format({ channels: displayChannels, countOnly: countOnly });
+}
+
+async function markAllChannelsAsRead(client: SlackApiClient, channels: Channel[]): Promise<void> {
+  for (const channel of channels) {
+    await client.markAsRead(channel.id);
+  }
+  console.log(chalk.green('✓ Marked all messages as read'));
+}
+
 async function handleAllChannelsUnread(
   client: SlackApiClient,
   options: UnreadOptions
 ): Promise<void> {
-  const channels = await client.listUnreadChannels();
+  const channels = await fetchAllUnreadChannels(client);
 
   if (channels.length === 0) {
     console.log(chalk.green('✓ No unread messages'));
     return;
   }
 
-  // Apply limit
   const limit = parseLimit(options.limit, DEFAULTS.UNREAD_DISPLAY_LIMIT);
-  const displayChannels = channels.slice(0, limit);
-
   const format = parseFormat(options.format);
   const countOnly = parseBoolean(options.countOnly);
 
-  const formatter = createChannelFormatter(format, countOnly);
-  formatter.format({ channels: displayChannels, countOnly: countOnly });
+  formatAllChannelsOutput(channels, format, countOnly, limit);
 
   if (parseBoolean(options.markRead)) {
-    // Mark all unread channels as read
-    for (const channel of channels) {
-      await client.markAsRead(channel.id);
-    }
-    console.log(chalk.green('✓ Marked all messages as read'));
+    await markAllChannelsAsRead(client, channels);
   }
 }
 

package/src/types/commands.ts

@@ -35,6 +35,7 @@ export interface HistoryOptions {
   channel: string;
   number?: string;
   since?: string;
+  format?: 'table' | 'simple' | 'json';
   profile?: string;
 }
 

package/src/utils/errors.ts

@@ -4,34 +4,30 @@ export class SlackCliError extends Error {
     public code?: string
   ) {
     super(message);
-    this.name = 'SlackCliError';
+    this.name = this.constructor.name;
   }
 }
 
 export class ConfigurationError extends SlackCliError {
   constructor(message: string) {
     super(message, 'CONFIGURATION_ERROR');
-    this.name = 'ConfigurationError';
   }
 }
 
 export class ValidationError extends SlackCliError {
   constructor(message: string) {
     super(message, 'VALIDATION_ERROR');
-    this.name = 'ValidationError';
   }
 }
 
 export class ApiError extends SlackCliError {
   constructor(message: string) {
     super(message, 'API_ERROR');
-    this.name = 'ApiError';
   }
 }
 
 export class FileError extends SlackCliError {
   constructor(message: string) {
     super(message, 'FILE_ERROR');
-    this.name = 'FileError';
   }
 }

package/src/utils/formatters/history-formatters.ts

@@ -0,0 +1,123 @@
+import chalk from 'chalk';
+import { AbstractFormatter, JsonFormatter, createFormatterFactory } from './base-formatter';
+import { formatSlackTimestamp } from '../date-utils';
+
+function formatTimestampFixed(slackTimestamp: string): string {
+  const timestamp = parseFloat(slackTimestamp);
+  const date = new Date(timestamp * 1000);
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, '0');
+  const day = String(date.getUTCDate()).padStart(2, '0');
+  const hours = String(date.getUTCHours()).padStart(2, '0');
+  const minutes = String(date.getUTCMinutes()).padStart(2, '0');
+  const seconds = String(date.getUTCSeconds()).padStart(2, '0');
+  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+}
+import { formatMessageWithMentions } from '../format-utils';
+import { Message as SlackMessage } from '../slack-api-client';
+
+export interface HistoryFormatterOptions {
+  channelName: string;
+  messages: SlackMessage[];
+  users: Map<string, string>;
+}
+
+class TableHistoryFormatter extends AbstractFormatter<HistoryFormatterOptions> {
+  format(options: HistoryFormatterOptions): void {
+    const { channelName, messages, users } = options;
+
+    console.log(chalk.bold(`\nMessage History for #${channelName}:`));
+
+    if (messages.length === 0) {
+      console.log(chalk.yellow('No messages found'));
+      return;
+    }
+
+    console.log('');
+    messages.forEach((message) => {
+      const timestamp = formatTimestampFixed(message.ts);
+      const username = this.getUsername(message, users);
+
+      console.log(`${chalk.gray(`[${timestamp}]`)} ${chalk.cyan(username)}`);
+      const text = message.text ? formatMessageWithMentions(message.text, users) : '(no text)';
+      console.log(text);
+      console.log('');
+    });
+
+    console.log(chalk.green(`✓ Displayed ${messages.length} message(s)`));
+  }
+
+  private getUsername(message: SlackMessage, users: Map<string, string>): string {
+    if (message.user) {
+      return users.get(message.user) || 'Unknown User';
+    }
+    if (message.bot_id) {
+      return 'Bot';
+    }
+    return 'Unknown';
+  }
+}
+
+class SimpleHistoryFormatter extends AbstractFormatter<HistoryFormatterOptions> {
+  format(options: HistoryFormatterOptions): void {
+    const { messages, users } = options;
+
+    if (messages.length === 0) {
+      console.log('No messages found');
+      return;
+    }
+
+    messages.forEach((message) => {
+      const timestamp = formatTimestampFixed(message.ts);
+      const username = this.getUsername(message, users);
+      const text = message.text ? formatMessageWithMentions(message.text, users) : '(no text)';
+      console.log(`[${timestamp}] ${username}: ${text}`);
+    });
+  }
+
+  private getUsername(message: SlackMessage, users: Map<string, string>): string {
+    if (message.user) {
+      return users.get(message.user) || 'Unknown User';
+    }
+    if (message.bot_id) {
+      return 'Bot';
+    }
+    return 'Unknown';
+  }
+}
+
+class JsonHistoryFormatter extends JsonFormatter<HistoryFormatterOptions> {
+  protected transform(options: HistoryFormatterOptions) {
+    const { channelName, messages, users } = options;
+
+    return {
+      channel: channelName,
+      messages: messages.map((message) => ({
+        timestamp: formatTimestampFixed(message.ts),
+        user: this.getUsername(message, users),
+        text: message.text || '(no text)',
+      })),
+      total: messages.length,
+    };
+  }
+
+  private getUsername(message: SlackMessage, users: Map<string, string>): string {
+    if (message.user) {
+      return users.get(message.user) || 'Unknown User';
+    }
+    if (message.bot_id) {
+      return 'Bot';
+    }
+    return 'Unknown';
+  }
+}
+
+const historyFormatterFactory = createFormatterFactory<HistoryFormatterOptions>({
+  table: new TableHistoryFormatter(),
+  simple: new SimpleHistoryFormatter(),
+  json: new JsonHistoryFormatter(),
+});
+
+export function createHistoryFormatter(format: string) {
+  return historyFormatterFactory.create(format);
+}

package/src/utils/validators.ts

@@ -190,6 +190,19 @@ export const optionValidators = {
     }
     return null;
   },
+
+  /**
+   * Validates format option
+   */
+  format: (options: Record<string, unknown>): string | null => {
+    if (options.format) {
+      const validFormats = ['table', 'simple', 'json'];
+      if (!validFormats.includes(options.format as string)) {
+        return `Invalid format '${options.format}'. Must be one of: ${validFormats.join(', ')}`;
+      }
+    }
+    return null;
+  },
 };
 
 /**

package/tests/commands/history.test.ts

@@ -217,6 +217,121 @@ describe('history command', () => {
   });
 
   describe('output formatting', () => {
+    describe('format options', () => {
+      it('should display messages in JSON format when --format json is specified', async () => {
+        vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+          token: 'test-token',
+          updatedAt: new Date().toISOString()
+        });
+
+        const mockMessages = [
+          {
+            type: 'message',
+            text: 'Hello world',
+            user: 'U123456',
+            ts: '1609459200.000100',
+          },
+          {
+            type: 'message',
+            text: 'Another message',
+            user: 'U789012',
+            ts: '1609459300.000200',
+          },
+        ];
+        
+        vi.mocked(mockSlackClient.getHistory).mockResolvedValue({
+          messages: mockMessages,
+          users: new Map([
+            ['U123456', 'john.doe'],
+            ['U789012', 'jane.smith']
+          ])
+        });
+
+        await program.parseAsync(['node', 'slack-cli', 'history', '-c', 'general', '--format', 'json']);
+
+        const expectedOutput = {
+          channel: 'general',
+          messages: [
+            {
+              timestamp: '2021-01-01 00:01:40',
+              user: 'jane.smith',
+              text: 'Another message'
+            },
+            {
+              timestamp: '2021-01-01 00:00:00',
+              user: 'john.doe',
+              text: 'Hello world'
+            }
+          ],
+          total: 2
+        };
+
+        expect(mockConsole.logSpy).toHaveBeenCalledWith(JSON.stringify(expectedOutput, null, 2));
+      });
+
+      it('should display messages in simple format when --format simple is specified', async () => {
+        vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+          token: 'test-token',
+          updatedAt: new Date().toISOString()
+        });
+
+        const mockMessages = [
+          {
+            type: 'message',
+            text: 'Hello world',
+            user: 'U123456',
+            ts: '1609459200.000100',
+          },
+        ];
+        
+        vi.mocked(mockSlackClient.getHistory).mockResolvedValue({
+          messages: mockMessages,
+          users: new Map([['U123456', 'john.doe']])
+        });
+
+        await program.parseAsync(['node', 'slack-cli', 'history', '-c', 'general', '--format', 'simple']);
+
+        expect(mockConsole.logSpy).toHaveBeenCalledWith('[2021-01-01 00:00:00] john.doe: Hello world');
+      });
+
+      it('should display messages in table format by default', async () => {
+        vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+          token: 'test-token',
+          updatedAt: new Date().toISOString()
+        });
+
+        const mockMessages = [
+          {
+            type: 'message',
+            text: 'Hello world',
+            user: 'U123456',
+            ts: '1609459200.000100',
+          },
+        ];
+        
+        vi.mocked(mockSlackClient.getHistory).mockResolvedValue({
+          messages: mockMessages,
+          users: new Map([['U123456', 'john.doe']])
+        });
+
+        await program.parseAsync(['node', 'slack-cli', 'history', '-c', 'general']);
+
+        // Should display in table format (current format)
+        expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Message History for #general'));
+        expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('john.doe'));
+        expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Hello world'));
+      });
+
+      it('should handle invalid format option', async () => {
+        const historyCommand = setupHistoryCommand();
+        historyCommand.exitOverride();
+        
+        await expect(
+          historyCommand.parseAsync(['-c', 'general', '--format', 'invalid'], { from: 'user' })
+        ).rejects.toThrow();
+      });
+    });
+
     it('should format messages with user names and timestamps', async () => {
       vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
         token: 'test-token',

package/tests/index.test.ts

@@ -4,7 +4,7 @@ import { readFileSync } from 'fs';
 import { join } from 'path';
 
 describe('slack-cli version', () => {
-  it('should display the correct version from package.json', () => {
+  it('should display the correct version from package.json', { timeout: 20000 }, () => {
     // Read the expected version from package.json
     const packageJson = JSON.parse(
       readFileSync(join(__dirname, '..', 'package.json'), 'utf-8')
@@ -21,7 +21,7 @@ describe('slack-cli version', () => {
     expect(output).toBe(expectedVersion);
   });
 
-  it('should display version with -V flag', () => {
+  it('should display version with -V flag', { timeout: 20000 }, () => {
     // Read the expected version from package.json
     const packageJson = JSON.parse(
       readFileSync(join(__dirname, '..', 'package.json'), 'utf-8')

package/.eslintrc.json

@@ -1,25 +0,0 @@
-{
-  "parser": "@typescript-eslint/parser",
-  "extends": [
-    "eslint:recommended",
-    "plugin:@typescript-eslint/recommended",
-    "prettier"
-  ],
-  "plugins": ["@typescript-eslint"],
-  "parserOptions": {
-    "ecmaVersion": 2020,
-    "sourceType": "module",
-    "project": "./tsconfig.json"
-  },
-  "env": {
-    "node": true,
-    "es2020": true
-  },
-  "rules": {
-    "@typescript-eslint/explicit-function-return-type": "off",
-    "@typescript-eslint/no-explicit-any": "warn",
-    "@typescript-eslint/no-unused-vars": ["error", { "argsIgnorePattern": "^_" }],
-    "no-console": "off"
-  },
-  "ignorePatterns": ["dist", "node_modules", "coverage", "vitest.config.ts"]
-}

package/dist/utils/config.d.ts

@@ -1,10 +0,0 @@
-import type { Config, ConfigOptions } from '../types/config';
-export declare class ConfigManager {
-    private configPath;
-    constructor(options?: ConfigOptions);
-    setToken(token: string): Promise<void>;
-    getConfig(): Promise<Config | null>;
-    clearConfig(): Promise<void>;
-    maskToken(token: string): string;
-}
-//# sourceMappingURL=config.d.ts.map

package/dist/utils/config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/utils/config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAE7D,qBAAa,aAAa;IACxB,OAAO,CAAC,UAAU,CAAS;gBAEf,OAAO,GAAE,aAAkB;IAKjC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAatC,SAAS,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAqBnC,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAUlC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;CAUjC"}