@urugus/slack-cli 0.2.12 → 0.3.0

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

@@ -1,55 +0,0 @@
-import { AbstractFormatter, JsonFormatter, createFormatterFactory } from './base-formatter';
-import { ChannelInfo } from '../channel-formatter';
-
-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));
-
-    // 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}`);
-    });
-  }
-}
-
-class ChannelsSimpleFormatter extends AbstractFormatter<ChannelsListFormatterOptions> {
-  format({ channels }: ChannelsListFormatterOptions): void {
-    channels.forEach((channel) => console.log(channel.name));
-  }
-}
-
-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,
-    }));
-  }
-}
-
-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/history-formatters.ts

@@ -1,123 +0,0 @@
-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/formatters/message-formatters.ts

@@ -1,85 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,100 +0,0 @@
-/**
- * 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.ts

@@ -1,161 +0,0 @@
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-import type { Config, ConfigOptions, ConfigStore, Profile } from '../types/config';
-import { DEFAULT_PROFILE_NAME, ERROR_MESSAGES, FILE_PERMISSIONS } from './constants';
-import { maskToken } from './token-utils';
-
-export class ProfileConfigManager {
-  private configPath: string;
-
-  constructor(options: ConfigOptions = {}) {
-    const configDir = options.configDir || path.join(os.homedir(), '.slack-cli');
-    this.configPath = path.join(configDir, 'config.json');
-  }
-
-  async setToken(token: string, profile?: string): Promise<void> {
-    const store = await this.getConfigStore();
-    const profileName = profile || store.defaultProfile || DEFAULT_PROFILE_NAME;
-    const config: Config = {
-      token,
-      updatedAt: new Date().toISOString(),
-    };
-
-    store.profiles[profileName] = config;
-
-    // Set as default profile if it's the first one or explicitly setting default
-    if (!store.defaultProfile || profileName === DEFAULT_PROFILE_NAME) {
-      store.defaultProfile = profileName;
-    }
-
-    await this.saveConfigStore(store);
-  }
-
-  async getConfig(profile?: string): Promise<Config | null> {
-    const store = await this.getConfigStore();
-    const profileName = profile || store.defaultProfile || DEFAULT_PROFILE_NAME;
-
-    return store.profiles[profileName] || null;
-  }
-
-  async listProfiles(): Promise<Profile[]> {
-    const store = await this.getConfigStore();
-    const currentProfile = store.defaultProfile || DEFAULT_PROFILE_NAME;
-
-    return Object.entries(store.profiles).map(([name, config]) => ({
-      name,
-      config,
-      isDefault: name === currentProfile,
-    }));
-  }
-
-  async useProfile(profile: string): Promise<void> {
-    const store = await this.getConfigStore();
-
-    if (!store.profiles[profile]) {
-      throw new Error(`Profile "${profile}" does not exist`);
-    }
-
-    store.defaultProfile = profile;
-    await this.saveConfigStore(store);
-  }
-
-  async getCurrentProfile(): Promise<string> {
-    const store = await this.getConfigStore();
-    return store.defaultProfile || DEFAULT_PROFILE_NAME;
-  }
-
-  async clearConfig(profile?: string): Promise<void> {
-    const store = await this.getConfigStore();
-    const profileName = profile || store.defaultProfile || DEFAULT_PROFILE_NAME;
-
-    delete store.profiles[profileName];
-
-    // If we deleted the default profile, set a new default
-    if (store.defaultProfile === profileName) {
-      const remainingProfiles = Object.keys(store.profiles);
-      if (remainingProfiles.length > 0) {
-        store.defaultProfile = remainingProfiles[0];
-      } else {
-        // No profiles left, delete the config file
-        try {
-          await fs.unlink(this.configPath);
-        } catch (error: unknown) {
-          if (error && typeof error === 'object' && 'code' in error && error.code !== 'ENOENT') {
-            throw error;
-          }
-        }
-        return;
-      }
-    }
-
-    await this.saveConfigStore(store);
-  }
-
-  maskToken(token: string): string {
-    return maskToken(token);
-  }
-
-  private async getConfigStore(): Promise<ConfigStore> {
-    try {
-      const data = await fs.readFile(this.configPath, 'utf-8');
-      const parsed = JSON.parse(data);
-
-      // Handle migration from old format
-      if (this.needsMigration(parsed)) {
-        return await this.migrateOldConfig(parsed);
-      }
-
-      return parsed as ConfigStore;
-    } catch (error: unknown) {
-      if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
-        return { profiles: {} };
-      }
-      if (error instanceof SyntaxError) {
-        throw new Error(ERROR_MESSAGES.INVALID_CONFIG_FORMAT);
-      }
-      throw error;
-    }
-  }
-
-  private needsMigration(data: unknown): boolean {
-    const configData = data as Record<string, unknown>;
-    return Boolean(configData.token && !configData.profiles);
-  }
-
-  private async migrateOldConfig(oldData: unknown): Promise<ConfigStore> {
-    const data = oldData as { token: string; updatedAt: string };
-    const oldConfig: Config = {
-      token: data.token,
-      updatedAt: data.updatedAt,
-    };
-
-    const newStore: ConfigStore = {
-      profiles: { [DEFAULT_PROFILE_NAME]: oldConfig },
-      defaultProfile: DEFAULT_PROFILE_NAME,
-    };
-
-    // Save migrated config
-    await this.saveConfigStore(newStore);
-    return newStore;
-  }
-
-  private async saveConfigStore(store: ConfigStore): Promise<void> {
-    const configDir = path.dirname(this.configPath);
-    await fs.mkdir(configDir, { recursive: true });
-
-    await fs.writeFile(this.configPath, JSON.stringify(store, null, 2));
-    await fs.chmod(this.configPath, FILE_PERMISSIONS.CONFIG_FILE);
-  }
-}
-
-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/schedule-utils.ts

@@ -1,41 +0,0 @@
-export function parseScheduledTimestamp(value: string): number | null {
-  const trimmed = value.trim();
-
-  if (/^\d+$/.test(trimmed)) {
-    const timestamp = Number.parseInt(trimmed, 10);
-    return Number.isSafeInteger(timestamp) ? timestamp : null;
-  }
-
-  const parsedMs = Date.parse(trimmed);
-  if (Number.isNaN(parsedMs)) {
-    return null;
-  }
-
-  return Math.floor(parsedMs / 1000);
-}
-
-export function resolvePostAt(
-  at: string | undefined,
-  afterMinutes: string | undefined,
-  nowMs = Date.now()
-): number | null {
-  if (at) {
-    return parseScheduledTimestamp(at);
-  }
-
-  if (!afterMinutes) {
-    return null;
-  }
-
-  const trimmedAfter = afterMinutes.trim();
-  if (!/^\d+$/.test(trimmedAfter)) {
-    return null;
-  }
-
-  const minutes = Number.parseInt(trimmedAfter, 10);
-  if (!Number.isSafeInteger(minutes) || minutes <= 0) {
-    return null;
-  }
-
-  return Math.floor(nowMs / 1000) + minutes * 60;
-}