@urugus/slack-cli 0.2.2 → 0.2.4

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

@@ -1,11 +1,16 @@
 import chalk from 'chalk';
-import { BaseFormatter } from './output-formatter';
+import { AbstractFormatter, JsonFormatter, createFormatterFactory } from './base-formatter';
 import { Channel } from '../slack-api-client';
 import { formatChannelName } from '../channel-formatter';
 import { formatSlackTimestamp } from '../date-utils';
 
-export class ChannelTableFormatter extends BaseFormatter<Channel> {
-  format(channels: Channel[]): void {
+export interface ChannelFormatterOptions {
+  channels: Channel[];
+  countOnly?: boolean;
+}
+
+class ChannelTableFormatter extends AbstractFormatter<ChannelFormatterOptions> {
+  format({ channels }: ChannelFormatterOptions): void {
     console.log(chalk.bold('Channel          Unread  Last Message'));
     console.log('─'.repeat(50));
 
@@ -19,8 +24,8 @@ export class ChannelTableFormatter extends BaseFormatter<Channel> {
   }
 }
 
-export class ChannelSimpleFormatter extends BaseFormatter<Channel> {
-  format(channels: Channel[]): void {
+class ChannelSimpleFormatter extends AbstractFormatter<ChannelFormatterOptions> {
+  format({ channels }: ChannelFormatterOptions): void {
     channels.forEach((channel) => {
       const channelName = formatChannelName(channel.name);
       console.log(`${channelName} (${channel.unread_count || 0})`);
@@ -28,19 +33,18 @@ export class ChannelSimpleFormatter extends BaseFormatter<Channel> {
   }
 }
 
-export class ChannelJsonFormatter extends BaseFormatter<Channel> {
-  format(channels: Channel[]): void {
-    const output = channels.map((channel) => ({
+class ChannelJsonFormatter extends JsonFormatter<ChannelFormatterOptions> {
+  protected transform({ channels }: ChannelFormatterOptions) {
+    return channels.map((channel) => ({
       channel: formatChannelName(channel.name),
       channelId: channel.id,
       unreadCount: channel.unread_count || 0,
     }));
-    console.log(JSON.stringify(output, null, 2));
   }
 }
 
-export class ChannelCountFormatter extends BaseFormatter<Channel> {
-  format(channels: Channel[]): void {
+class ChannelCountFormatter extends AbstractFormatter<ChannelFormatterOptions> {
+  format({ channels }: ChannelFormatterOptions): void {
     let totalUnread = 0;
     channels.forEach((channel) => {
       const count = channel.unread_count || 0;
@@ -52,18 +56,16 @@ export class ChannelCountFormatter extends BaseFormatter<Channel> {
   }
 }
 
-export function createChannelFormatter(format: string, countOnly: boolean): BaseFormatter<Channel> {
-  if (countOnly) {
-    return new ChannelCountFormatter();
-  }
+const channelFormatterFactory = createFormatterFactory<ChannelFormatterOptions>({
+  table: new ChannelTableFormatter(),
+  simple: new ChannelSimpleFormatter(),
+  json: new ChannelJsonFormatter(),
+  count: new ChannelCountFormatter(),
+});
 
-  switch (format) {
-    case 'json':
-      return new ChannelJsonFormatter();
-    case 'simple':
-      return new ChannelSimpleFormatter();
-    case 'table':
-    default:
-      return new ChannelTableFormatter();
+export function createChannelFormatter(format: string, countOnly: boolean) {
+  if (countOnly) {
+    return channelFormatterFactory.create('count');
   }
+  return channelFormatterFactory.create(format);
 }

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

@@ -1,8 +1,12 @@
-import { BaseFormatter } from './output-formatter';
+import { AbstractFormatter, JsonFormatter, createFormatterFactory } from './base-formatter';
 import { ChannelInfo } from '../channel-formatter';
 
-export class ChannelsTableFormatter extends BaseFormatter<ChannelInfo> {
-  format(channels: ChannelInfo[]): void {
+export interface ChannelsListFormatterOptions {
+  channels: ChannelInfo[];
+}
+
+class ChannelsTableFormatter extends AbstractFormatter<ChannelsListFormatterOptions> {
+  format({ channels }: ChannelsListFormatterOptions): void {
     // Print table header
     console.log('Name              Type      Members  Created      Description');
     console.log('─'.repeat(65));
@@ -21,39 +25,31 @@ export class ChannelsTableFormatter extends BaseFormatter<ChannelInfo> {
   }
 }
 
-export class ChannelsSimpleFormatter extends BaseFormatter<ChannelInfo> {
-  format(channels: ChannelInfo[]): void {
+class ChannelsSimpleFormatter extends AbstractFormatter<ChannelsListFormatterOptions> {
+  format({ channels }: ChannelsListFormatterOptions): 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
-      )
-    );
+class ChannelsJsonFormatter extends JsonFormatter<ChannelsListFormatterOptions> {
+  protected transform({ channels }: ChannelsListFormatterOptions) {
+    return channels.map((channel) => ({
+      id: channel.id,
+      name: channel.name,
+      type: channel.type,
+      members: channel.members,
+      created: channel.created + 'T00:00:00Z',
+      purpose: channel.purpose,
+    }));
   }
 }
 
-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();
-  }
+const channelsListFormatterFactory = createFormatterFactory<ChannelsListFormatterOptions>({
+  table: new ChannelsTableFormatter(),
+  simple: new ChannelsSimpleFormatter(),
+  json: new ChannelsJsonFormatter(),
+});
+
+export function createChannelsListFormatter(format: string) {
+  return channelsListFormatterFactory.create(format);
 }

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

@@ -0,0 +1,85 @@
+import chalk from 'chalk';
+import { AbstractFormatter, JsonFormatter, createFormatterFactory } from './base-formatter';
+import { formatSlackTimestamp } from '../date-utils';
+import { formatMessageWithMentions } from '../format-utils';
+import { formatChannelName } from '../channel-formatter';
+
+export interface MessageFormatterOptions {
+  channel: any;
+  messages: any[];
+  users: Map<string, string>;
+  countOnly: boolean;
+  format: string;
+}
+
+class TableMessageFormatter extends AbstractFormatter<MessageFormatterOptions> {
+  format(options: MessageFormatterOptions): void {
+    const { channel, messages, users, countOnly } = options;
+    const channelName = formatChannelName(channel.name);
+
+    console.log(chalk.bold(`${channelName}: ${channel.unread_count || 0} unread messages`));
+
+    if (!countOnly && messages.length > 0) {
+      console.log('');
+      messages.forEach((message) => {
+        const timestamp = formatSlackTimestamp(message.ts);
+        const author = message.user ? users.get(message.user) || message.user : 'unknown';
+        console.log(`${chalk.gray(timestamp)} ${chalk.cyan(author)}`);
+        const text = message.text ? formatMessageWithMentions(message.text, users) : '(no text)';
+        console.log(text);
+        console.log('');
+      });
+    }
+  }
+}
+
+class SimpleMessageFormatter extends AbstractFormatter<MessageFormatterOptions> {
+  format(options: MessageFormatterOptions): void {
+    const { channel, messages, users, countOnly } = options;
+    const channelName = formatChannelName(channel.name);
+
+    console.log(`${channelName} (${channel.unread_count || 0})`);
+
+    if (!countOnly && messages.length > 0) {
+      messages.forEach((message) => {
+        const timestamp = formatSlackTimestamp(message.ts);
+        const author = message.user ? users.get(message.user) || message.user : 'unknown';
+        const text = message.text ? formatMessageWithMentions(message.text, users) : '(no text)';
+        console.log(`[${timestamp}] ${author}: ${text}`);
+      });
+    }
+  }
+}
+
+class JsonMessageFormatter extends JsonFormatter<MessageFormatterOptions> {
+  protected transform(options: MessageFormatterOptions) {
+    const { channel, messages, users, countOnly } = options;
+    const channelName = formatChannelName(channel.name);
+
+    const output: any = {
+      channel: channelName,
+      channelId: channel.id,
+      unreadCount: channel.unread_count || 0,
+    };
+
+    if (!countOnly && messages.length > 0) {
+      output.messages = messages.map((message) => ({
+        timestamp: formatSlackTimestamp(message.ts),
+        author: message.user ? users.get(message.user) || message.user : 'unknown',
+        text: message.text || '(no text)',
+      }));
+    }
+
+    return output;
+  }
+}
+
+const messageFormatterFactory = createFormatterFactory<MessageFormatterOptions>({
+  table: new TableMessageFormatter(),
+  simple: new SimpleMessageFormatter(),
+  json: new JsonMessageFormatter(),
+});
+
+export function createMessageFormatter(format: string) {
+  return messageFormatterFactory.create(format);
+}

package/src/utils/mention-utils.ts

@@ -0,0 +1,47 @@
+import { USER_MENTION_PATTERN } from './slack-patterns';
+
+/**
+ * Extracts all user IDs from mentions in a text
+ * @param text - The text containing Slack mentions
+ * @returns Array of unique user IDs found in mentions
+ */
+export function extractUserIdsFromMentions(text: string): string[] {
+  const userIds: string[] = [];
+  const matches = text.matchAll(USER_MENTION_PATTERN);
+
+  for (const match of matches) {
+    const userId = match[1];
+    if (userId) {
+      userIds.push(userId);
+    }
+  }
+
+  return userIds;
+}
+
+/**
+ * Extracts all unique user IDs from an array of messages
+ * Includes both message authors and mentioned users
+ * @param messages - Array of messages to extract user IDs from
+ * @returns Array of unique user IDs
+ */
+export function extractAllUserIds(messages: Array<{ user?: string; text?: string }>): string[] {
+  const userIds = new Set<string>();
+
+  for (const message of messages) {
+    // Add message author
+    if (message.user) {
+      userIds.add(message.user);
+    }
+
+    // Add mentioned users
+    if (message.text) {
+      const mentionedIds = extractUserIdsFromMentions(message.text);
+      for (const id of mentionedIds) {
+        userIds.add(id);
+      }
+    }
+  }
+
+  return Array.from(userIds);
+}

package/src/utils/option-parsers.ts

@@ -0,0 +1,100 @@
+/**
+ * Common option parsing utilities to reduce duplication
+ */
+
+/**
+ * Parse format option with default value
+ */
+export function parseFormat(format?: string, defaultFormat = 'table'): string {
+  return format || defaultFormat;
+}
+
+/**
+ * Parse limit option with default value
+ */
+export function parseLimit(limit: string | undefined, defaultLimit: number): number {
+  return parseInt(limit || defaultLimit.toString(), 10);
+}
+
+/**
+ * Parse boolean option with default value
+ */
+export function parseBoolean(value?: boolean, defaultValue = false): boolean {
+  return value !== undefined ? value : defaultValue;
+}
+
+/**
+ * Parse count option with default value
+ */
+export function parseCount(
+  count: string | undefined,
+  defaultCount: number,
+  min?: number,
+  max?: number
+): number {
+  const parsed = parseInt(count || defaultCount.toString(), 10);
+
+  if (isNaN(parsed)) {
+    return defaultCount;
+  }
+
+  if (min !== undefined && parsed < min) {
+    return min;
+  }
+
+  if (max !== undefined && parsed > max) {
+    return max;
+  }
+
+  return parsed;
+}
+
+/**
+ * Parse profile option
+ */
+export function parseProfile(profile?: string): string | undefined {
+  return profile;
+}
+
+/**
+ * Common option defaults
+ */
+export const OPTION_DEFAULTS = {
+  format: 'table',
+  limit: 100,
+  countOnly: false,
+  includeArchived: false,
+} as const;
+
+/**
+ * Parse common list options
+ */
+export interface ListOptions {
+  format?: string;
+  limit?: string;
+  countOnly?: boolean;
+}
+
+export interface ParsedListOptions {
+  format: string;
+  limit: number;
+  countOnly: boolean;
+}
+
+export function parseListOptions(
+  options: ListOptions,
+  defaults?: Partial<ParsedListOptions>
+): ParsedListOptions {
+  const mergedDefaults = {
+    format: OPTION_DEFAULTS.format,
+    limit: OPTION_DEFAULTS.limit,
+    countOnly: OPTION_DEFAULTS.countOnly,
+    ...defaults,
+  };
+
+  return {
+    format: parseFormat(options.format, mergedDefaults.format),
+    limit: parseLimit(options.limit, mergedDefaults.limit),
+    countOnly: parseBoolean(options.countOnly, mergedDefaults.countOnly),
+  };
+}

package/src/utils/profile-config-refactored.ts

@@ -0,0 +1,161 @@
+import type { Config, ConfigOptions, Profile } from '../types/config';
+import { TOKEN_MASK_LENGTH, TOKEN_MIN_LENGTH, DEFAULT_PROFILE_NAME } from './constants';
+import { ConfigFileManager } from './config/config-file-manager';
+import { TokenCryptoService } from './config/token-crypto-service';
+import { ProfileManager } from './config/profile-manager';
+import * as fs from 'fs/promises';
+
+export class ProfileConfigManager {
+  private fileManager: ConfigFileManager;
+  private cryptoService: TokenCryptoService;
+  private profileManager: ProfileManager;
+
+  constructor(_options: ConfigOptions = {}) {
+    // Note: ConfigFileManager currently doesn't support custom configDir
+    // This would need to be added if required
+    this.fileManager = new ConfigFileManager();
+    this.cryptoService = new TokenCryptoService();
+    this.profileManager = new ProfileManager(this.fileManager, this.cryptoService);
+  }
+
+  async setToken(token: string, profile?: string): Promise<void> {
+    const profileName = profile || (await this.profileManager.getCurrentProfile());
+    const config: Config = {
+      token,
+      updatedAt: new Date().toISOString(),
+    };
+
+    await this.profileManager.setProfile(profileName, config);
+
+    // Set as default profile if it's the first one or explicitly setting default
+    const profiles = await this.profileManager.listProfiles();
+    if (profiles.length === 1 || profileName === DEFAULT_PROFILE_NAME) {
+      await this.profileManager.setCurrentProfile(profileName);
+    }
+  }
+
+  async getConfig(profile?: string): Promise<Config | null> {
+    const profileName = profile || (await this.profileManager.getCurrentProfile());
+
+    try {
+      return await this.profileManager.getProfile(profileName);
+    } catch (error) {
+      // Return null if profile not found
+      if (error instanceof Error && error.message.includes('not found')) {
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  async listProfiles(): Promise<Profile[]> {
+    const profileNames = await this.profileManager.listProfiles();
+    const currentProfile = await this.profileManager.getCurrentProfile();
+
+    const profiles: Profile[] = [];
+    for (const name of profileNames) {
+      const config = await this.profileManager.getProfile(name);
+      profiles.push({
+        name,
+        config,
+        isDefault: name === currentProfile,
+      });
+    }
+
+    return profiles;
+  }
+
+  async useProfile(profile: string): Promise<void> {
+    const exists = await this.profileManager.profileExists(profile);
+    if (!exists) {
+      throw new Error(`Profile "${profile}" does not exist`);
+    }
+
+    await this.profileManager.setCurrentProfile(profile);
+  }
+
+  async getCurrentProfile(): Promise<string> {
+    return await this.profileManager.getCurrentProfile();
+  }
+
+  async clearConfig(profile?: string): Promise<void> {
+    const profileName = profile || (await this.profileManager.getCurrentProfile());
+
+    try {
+      await this.profileManager.deleteProfile(profileName);
+    } catch (error) {
+      // If profile doesn't exist, do nothing
+      if (error instanceof Error && error.message.includes('not found')) {
+        return;
+      }
+      throw error;
+    }
+
+    // If we deleted the current profile, set a new default
+    const currentProfile = await this.profileManager.getCurrentProfile();
+    if (currentProfile === profileName) {
+      const remainingProfiles = await this.profileManager.listProfiles();
+      if (remainingProfiles.length > 0) {
+        await this.profileManager.setCurrentProfile(remainingProfiles[0]);
+      } else {
+        // No profiles left, delete the config file
+        try {
+          await fs.unlink(this.fileManager.getConfigPath());
+        } catch (error: unknown) {
+          if (error && typeof error === 'object' && 'code' in error && error.code !== 'ENOENT') {
+            throw error;
+          }
+        }
+      }
+    }
+  }
+
+  maskToken(token: string): string {
+    if (token.length <= TOKEN_MIN_LENGTH) {
+      return '****';
+    }
+
+    const prefix = token.substring(0, TOKEN_MASK_LENGTH);
+    const suffix = token.substring(token.length - TOKEN_MASK_LENGTH);
+
+    return `${prefix}-****-****-${suffix}`;
+  }
+
+  // Migration support - to be called separately if needed
+  async migrateIfNeeded(): Promise<void> {
+    const data = await this.fileManager.read();
+
+    // Check if migration is needed (old format detection)
+    const anyData = data as unknown as Record<string, unknown>;
+    if (anyData.token && !anyData.profiles) {
+      // Old format detected, migrate
+      const oldConfig: Config = {
+        token: anyData.token as string,
+        updatedAt: (anyData.updatedAt as string) || new Date().toISOString(),
+      };
+
+      // Create new format
+      const newData = {
+        profiles: { [DEFAULT_PROFILE_NAME]: oldConfig },
+        currentProfile: DEFAULT_PROFILE_NAME,
+      };
+
+      await this.fileManager.write(newData);
+
+      // Re-encrypt token using new service
+      await this.setToken(oldConfig.token, DEFAULT_PROFILE_NAME);
+    }
+  }
+}
+
+// Export a simplified version for backward compatibility
+export const profileConfig = {
+  getCurrentProfile: (): string => {
+    return DEFAULT_PROFILE_NAME;
+  },
+  getToken: (_profile?: string): string | undefined => {
+    // This is a simplified version for testing
+    // In real usage, it would need to be async
+    return undefined;
+  },
+};

package/src/utils/slack-operations/message-operations.ts

@@ -4,6 +4,7 @@ import { channelResolver } from '../channel-resolver';
 import { DEFAULTS } from '../constants';
 import { Message, HistoryOptions, HistoryResult, ChannelUnreadResult } from '../slack-api-client';
 import { ChannelOperations } from './channel-operations';
+import { extractAllUserIds } from '../mention-utils';
 
 export class MessageOperations extends BaseSlackClient {
   private channelOps: ChannelOperations;
@@ -38,8 +39,8 @@ export class MessageOperations extends BaseSlackClient {
 
     const messages = response.messages as Message[];
 
-    // Get unique user IDs
-    const userIds = [...new Set(messages.filter((m) => m.user).map((m) => m.user!))];
+    // Extract all unique user IDs (authors and mentioned users)
+    const userIds = extractAllUserIds(messages);
     const users = await this.fetchUserInfo(userIds);
 
     return { messages, users };

package/src/utils/slack-patterns.ts

@@ -0,0 +1,9 @@
+/**
+ * Common regex patterns for Slack message parsing
+ */
+
+// Matches Slack user mentions in the format <@USERID>
+export const USER_MENTION_PATTERN = /<@([A-Z0-9]+)>/g;
+
+// Matches a single user mention (non-global)
+export const SINGLE_USER_MENTION_PATTERN = /<@([A-Z0-9]+)>/;