@urugus/slack-cli 0.1.6 → 0.1.8

package/src/commands/config-subcommands.ts

@@ -0,0 +1,63 @@
+import chalk from 'chalk';
+import { ProfileConfigManager } from '../utils/profile-config';
+import { getProfileName } from '../utils/command-wrapper';
+import { ERROR_MESSAGES, SUCCESS_MESSAGES } from '../utils/constants';
+
+export async function handleSetToken(options: { token: string; profile?: string }): Promise<void> {
+  const configManager = new ProfileConfigManager();
+  const profileName = await getProfileName(configManager, options.profile);
+  await configManager.setToken(options.token, options.profile);
+  console.log(chalk.green(`✓ ${SUCCESS_MESSAGES.TOKEN_SAVED(profileName)}`));
+}
+
+export async function handleGetConfig(options: { profile?: string }): Promise<void> {
+  const configManager = new ProfileConfigManager();
+  const profileName = await getProfileName(configManager, options.profile);
+  const currentConfig = await configManager.getConfig(options.profile);
+
+  if (!currentConfig) {
+    console.log(chalk.yellow(ERROR_MESSAGES.NO_CONFIG(profileName)));
+    return;
+  }
+
+  console.log(chalk.bold(`Configuration for profile "${profileName}":`));
+  console.log(`  Token: ${chalk.cyan(configManager.maskToken(currentConfig.token))}`);
+  console.log(`  Updated: ${chalk.gray(currentConfig.updatedAt)}`);
+}
+
+export async function handleListProfiles(): Promise<void> {
+  const configManager = new ProfileConfigManager();
+  const profiles = await configManager.listProfiles();
+  const currentProfile = await configManager.getCurrentProfile();
+
+  if (profiles.length === 0) {
+    console.log(chalk.yellow(ERROR_MESSAGES.NO_PROFILES_FOUND));
+    return;
+  }
+
+  console.log(chalk.bold('Available profiles:'));
+  profiles.forEach((profile) => {
+    const marker = profile.name === currentProfile ? '*' : ' ';
+    const maskedToken = configManager.maskToken(profile.config.token);
+    console.log(`  ${marker} ${chalk.cyan(profile.name)} (${maskedToken})`);
+  });
+}
+
+export async function handleUseProfile(profile: string): Promise<void> {
+  const configManager = new ProfileConfigManager();
+  await configManager.useProfile(profile);
+  console.log(chalk.green(`✓ ${SUCCESS_MESSAGES.PROFILE_SWITCHED(profile)}`));
+}
+
+export async function handleShowCurrentProfile(): Promise<void> {
+  const configManager = new ProfileConfigManager();
+  const currentProfile = await configManager.getCurrentProfile();
+  console.log(chalk.bold(`Current profile: ${chalk.cyan(currentProfile)}`));
+}
+
+export async function handleClearConfig(options: { profile?: string }): Promise<void> {
+  const configManager = new ProfileConfigManager();
+  const profileName = await getProfileName(configManager, options.profile);
+  await configManager.clearConfig(options.profile);
+  console.log(chalk.green(`✓ ${SUCCESS_MESSAGES.PROFILE_CLEARED(profileName)}`));
+}

package/src/commands/config.ts

@@ -1,8 +1,13 @@
 import { Command } from 'commander';
-import chalk from 'chalk';
-import { ProfileConfigManager } from '../utils/profile-config';
-import { wrapCommand, getProfileName } from '../utils/command-wrapper';
-import { ERROR_MESSAGES, SUCCESS_MESSAGES } from '../utils/constants';
+import { wrapCommand } from '../utils/command-wrapper';
+import {
+  handleSetToken,
+  handleGetConfig,
+  handleListProfiles,
+  handleUseProfile,
+  handleShowCurrentProfile,
+  handleClearConfig,
+} from './config-subcommands';
 
 export function setupConfigCommand(): Command {
   const config = new Command('config').description('Manage Slack CLI configuration');
@@ -12,93 +17,34 @@ export function setupConfigCommand(): Command {
     .description('Set API token')
     .requiredOption('--token <token>', 'Slack API token')
     .option('--profile <profile>', 'Profile name (default: "default")')
-    .action(
-      wrapCommand(async (options) => {
-        const configManager = new ProfileConfigManager();
-        const profileName = await getProfileName(configManager, options.profile);
-        await configManager.setToken(options.token, options.profile);
-        console.log(chalk.green(`✓ ${SUCCESS_MESSAGES.TOKEN_SAVED(profileName)}`));
-      })
-    );
+    .action(wrapCommand(handleSetToken));
 
   config
     .command('get')
     .description('Show current configuration')
     .option('--profile <profile>', 'Profile name')
-    .action(
-      wrapCommand(async (options) => {
-        const configManager = new ProfileConfigManager();
-        const profileName = await getProfileName(configManager, options.profile);
-        const currentConfig = await configManager.getConfig(options.profile);
-
-        if (!currentConfig) {
-          console.log(chalk.yellow(ERROR_MESSAGES.NO_CONFIG(profileName)));
-          return;
-        }
-
-        console.log(chalk.bold(`Configuration for profile "${profileName}":`));
-        console.log(`  Token: ${chalk.cyan(configManager.maskToken(currentConfig.token))}`);
-        console.log(`  Updated: ${chalk.gray(currentConfig.updatedAt)}`);
-      })
-    );
+    .action(wrapCommand(handleGetConfig));
 
   config
     .command('profiles')
     .description('List all profiles')
-    .action(
-      wrapCommand(async () => {
-        const configManager = new ProfileConfigManager();
-        const profiles = await configManager.listProfiles();
-        const currentProfile = await configManager.getCurrentProfile();
-
-        if (profiles.length === 0) {
-          console.log(chalk.yellow(ERROR_MESSAGES.NO_PROFILES_FOUND));
-          return;
-        }
-
-        console.log(chalk.bold('Available profiles:'));
-        profiles.forEach((profile) => {
-          const marker = profile.name === currentProfile ? '*' : ' ';
-          const maskedToken = configManager.maskToken(profile.config.token);
-          console.log(`  ${marker} ${chalk.cyan(profile.name)} (${maskedToken})`);
-        });
-      })
-    );
+    .action(wrapCommand(handleListProfiles));
 
   config
     .command('use <profile>')
     .description('Switch to a different profile')
-    .action(
-      wrapCommand(async (profile) => {
-        const configManager = new ProfileConfigManager();
-        await configManager.useProfile(profile);
-        console.log(chalk.green(`✓ ${SUCCESS_MESSAGES.PROFILE_SWITCHED(profile)}`));
-      })
-    );
+    .action(wrapCommand(handleUseProfile));
 
   config
     .command('current')
     .description('Show current active profile')
-    .action(
-      wrapCommand(async () => {
-        const configManager = new ProfileConfigManager();
-        const currentProfile = await configManager.getCurrentProfile();
-        console.log(chalk.bold(`Current profile: ${chalk.cyan(currentProfile)}`));
-      })
-    );
+    .action(wrapCommand(handleShowCurrentProfile));
 
   config
     .command('clear')
     .description('Clear configuration')
     .option('--profile <profile>', 'Profile name')
-    .action(
-      wrapCommand(async (options) => {
-        const configManager = new ProfileConfigManager();
-        const profileName = await getProfileName(configManager, options.profile);
-        await configManager.clearConfig(options.profile);
-        console.log(chalk.green(`✓ ${SUCCESS_MESSAGES.PROFILE_CLEARED(profileName)}`));
-      })
-    );
+    .action(wrapCommand(handleClearConfig));
 
   return config;
 }

package/src/commands/history-display.ts

@@ -0,0 +1,36 @@
+import chalk from 'chalk';
+import { Message } from '../utils/slack-api-client';
+import { formatSlackTimestamp } from '../utils/date-utils';
+
+export function displayHistoryResults(
+  messages: Message[],
+  users: Map<string, string>,
+  channelName: string
+): 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';
+
+    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) {
+      console.log(message.text);
+    }
+    console.log(''); // Empty line between messages
+  });
+
+  console.log(chalk.green(`✓ Displayed ${messages.length} message(s)`));
+}

package/src/commands/history-validators.ts

@@ -0,0 +1,46 @@
+import { Command } from 'commander';
+import { API_LIMITS } from '../utils/constants';
+
+export function validateMessageCount(
+  value: string | undefined,
+  command: Command
+): number | undefined {
+  if (!value) {
+    return undefined;
+  }
+
+  const num = parseInt(value, 10);
+  if (isNaN(num) || num < API_LIMITS.MIN_MESSAGE_COUNT || num > API_LIMITS.MAX_MESSAGE_COUNT) {
+    command.error(
+      `Error: Message count must be between ${API_LIMITS.MIN_MESSAGE_COUNT} and ${API_LIMITS.MAX_MESSAGE_COUNT}`
+    );
+  }
+
+  return num;
+}
+
+export function validateDateFormat(
+  value: string | undefined,
+  command: Command
+): string | undefined {
+  if (!value) {
+    return undefined;
+  }
+
+  const timestamp = Date.parse(value);
+  if (isNaN(timestamp)) {
+    command.error('Error: Invalid date format. Use YYYY-MM-DD HH:MM:SS');
+  }
+
+  return value;
+}
+
+export function prepareSinceTimestamp(since: string | undefined): string | undefined {
+  if (!since) {
+    return undefined;
+  }
+
+  // Convert date to Unix timestamp (in seconds)
+  const timestamp = Math.floor(Date.parse(since) / 1000);
+  return timestamp.toString();
+}

package/src/commands/history.ts

@@ -1,11 +1,15 @@
 import { Command } from 'commander';
-import chalk from 'chalk';
-import { HistoryOptions as ApiHistoryOptions, Message } from '../utils/slack-api-client';
+import { HistoryOptions as ApiHistoryOptions } from '../utils/slack-api-client';
 import { wrapCommand } from '../utils/command-wrapper';
 import { createSlackClient } from '../utils/client-factory';
 import { HistoryOptions } from '../types/commands';
-import { formatSlackTimestamp } from '../utils/date-utils';
 import { API_LIMITS } from '../utils/constants';
+import {
+  validateMessageCount,
+  validateDateFormat,
+  prepareSinceTimestamp,
+} from './history-validators';
+import { displayHistoryResults } from './history-display';
 
 export function setupHistoryCommand(): Command {
   const historyCommand = new Command('history')
@@ -20,75 +24,24 @@ export function setupHistoryCommand(): Command {
     .option('--profile <profile>', 'Use specific workspace profile')
     .hook('preAction', (thisCommand) => {
       const options = thisCommand.opts();
-
-      // Validate number option
-      if (options.number) {
-        const num = parseInt(options.number, 10);
-        if (
-          isNaN(num) ||
-          num < API_LIMITS.MIN_MESSAGE_COUNT ||
-          num > API_LIMITS.MAX_MESSAGE_COUNT
-        ) {
-          thisCommand.error(
-            `Error: Message count must be between ${API_LIMITS.MIN_MESSAGE_COUNT} and ${API_LIMITS.MAX_MESSAGE_COUNT}`
-          );
-        }
-      }
-
-      // Validate since option
-      if (options.since) {
-        const timestamp = Date.parse(options.since);
-        if (isNaN(timestamp)) {
-          thisCommand.error('Error: Invalid date format. Use YYYY-MM-DD HH:MM:SS');
-        }
-      }
+      validateMessageCount(options.number, thisCommand);
+      validateDateFormat(options.since, thisCommand);
     })
     .action(
       wrapCommand(async (options: HistoryOptions) => {
-        // Create Slack client
         const client = await createSlackClient(options.profile);
 
-        // Prepare API options
         const historyOptions: ApiHistoryOptions = {
           limit: parseInt(options.number || API_LIMITS.DEFAULT_MESSAGE_COUNT.toString(), 10),
         };
 
-        if (options.since) {
-          // Convert date to Unix timestamp (in seconds)
-          const timestamp = Math.floor(Date.parse(options.since) / 1000);
-          historyOptions.oldest = timestamp.toString();
+        const oldest = prepareSinceTimestamp(options.since);
+        if (oldest) {
+          historyOptions.oldest = oldest;
         }
 
-        // Get message history
         const { messages, users } = await client.getHistory(options.channel, historyOptions);
-
-        // Display results
-        if (messages.length === 0) {
-          console.log(chalk.yellow('No messages found in the specified channel.'));
-          return;
-        }
-
-        console.log(chalk.bold(`\nMessage History for #${options.channel}:\n`));
-
-        // Display messages in reverse order (oldest first)
-        messages.reverse().forEach((message: Message) => {
-          const timestamp = formatSlackTimestamp(message.ts);
-          let author = 'Unknown';
-
-          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) {
-            console.log(message.text);
-          }
-          console.log(''); // Empty line between messages
-        });
-
-        console.log(chalk.green(`✓ Displayed ${messages.length} message(s)`));
+        displayHistoryResults(messages, users, options.channel);
       })
     );
 

package/src/utils/channel-formatter.ts

@@ -27,63 +27,19 @@ export function mapChannelToInfo(channel: Channel): ChannelInfo {
   };
 }
 
-export function formatChannelsAsTable(channels: ChannelInfo[]): void {
-  // Print table header
-  console.log('Name              Type      Members  Created      Description');
-  console.log('─'.repeat(65));
-
-  // Print channel rows
-  channels.forEach((channel) => {
-    const name = channel.name.padEnd(17);
-    const type = channel.type.padEnd(9);
-    const members = channel.members.toString().padEnd(8);
-    const created = channel.created.padEnd(12);
-    const purpose =
-      channel.purpose.length > 30 ? channel.purpose.substring(0, 27) + '...' : channel.purpose;
-
-    console.log(`${name} ${type} ${members} ${created} ${purpose}`);
-  });
-}
-
-export function formatChannelsAsSimple(channels: ChannelInfo[]): void {
-  channels.forEach((channel) => console.log(channel.name));
-}
-
-export function formatChannelsAsJson(channels: ChannelInfo[]): void {
-  console.log(
-    JSON.stringify(
-      channels.map((channel) => ({
-        id: channel.id,
-        name: channel.name,
-        type: channel.type,
-        members: channel.members,
-        created: channel.created + 'T00:00:00Z',
-        purpose: channel.purpose,
-      })),
-      null,
-      2
-    )
-  );
-}
-
 export function formatChannelName(channelName?: string): string {
   if (!channelName) return '#unknown';
   return channelName.startsWith('#') ? channelName : `#${channelName}`;
 }
 
 export function getChannelTypes(type: string): string {
-  switch (type) {
-    case 'public':
-      return 'public_channel';
-    case 'private':
-      return 'private_channel';
-    case 'im':
-      return 'im';
-    case 'mpim':
-      return 'mpim';
-    case 'all':
-      return 'public_channel,private_channel,mpim,im';
-    default:
-      return 'public_channel';
-  }
+  const channelTypeMap: Record<string, string> = {
+    public: 'public_channel',
+    private: 'private_channel',
+    im: 'im',
+    mpim: 'mpim',
+    all: 'public_channel,private_channel,mpim,im',
+  };
+
+  return channelTypeMap[type] || 'public_channel';
 }

package/src/utils/formatters/channels-list-formatters.ts

@@ -0,0 +1,59 @@
+import { BaseFormatter } from './output-formatter';
+import { ChannelInfo } from '../channel-formatter';
+
+export class ChannelsTableFormatter extends BaseFormatter<ChannelInfo> {
+  format(channels: ChannelInfo[]): void {
+    // Print table header
+    console.log('Name              Type      Members  Created      Description');
+    console.log('─'.repeat(65));
+
+    // Print channel rows
+    channels.forEach((channel) => {
+      const name = channel.name.padEnd(17);
+      const type = channel.type.padEnd(9);
+      const members = channel.members.toString().padEnd(8);
+      const created = channel.created.padEnd(12);
+      const purpose =
+        channel.purpose.length > 30 ? channel.purpose.substring(0, 27) + '...' : channel.purpose;
+
+      console.log(`${name} ${type} ${members} ${created} ${purpose}`);
+    });
+  }
+}
+
+export class ChannelsSimpleFormatter extends BaseFormatter<ChannelInfo> {
+  format(channels: ChannelInfo[]): void {
+    channels.forEach((channel) => console.log(channel.name));
+  }
+}
+
+export class ChannelsJsonFormatter extends BaseFormatter<ChannelInfo> {
+  format(channels: ChannelInfo[]): void {
+    console.log(
+      JSON.stringify(
+        channels.map((channel) => ({
+          id: channel.id,
+          name: channel.name,
+          type: channel.type,
+          members: channel.members,
+          created: channel.created + 'T00:00:00Z',
+          purpose: channel.purpose,
+        })),
+        null,
+        2
+      )
+    );
+  }
+}
+
+export function createChannelsListFormatter(format: string): BaseFormatter<ChannelInfo> {
+  switch (format) {
+    case 'json':
+      return new ChannelsJsonFormatter();
+    case 'simple':
+      return new ChannelsSimpleFormatter();
+    case 'table':
+    default:
+      return new ChannelsTableFormatter();
+  }
+}