@memnexus-ai/cli 0.1.0

package/src/commands/communities.ts

@@ -0,0 +1,153 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import {
+  listCommunities,
+  getCommunityById,
+  mergeCommunities,
+} from '@memnexus-ai/mx-typescript-sdk';
+import { getApiOptions } from '../lib/api-client';
+import { handleError } from '../lib/errors';
+import { printOutput } from '../lib/formatters';
+import { OutputFormat } from '../types';
+
+/**
+ * Register community management commands
+ * @param program - Commander program instance
+ */
+export function registerCommunitiesCommands(program: Command): void {
+  const communities = program.command('communities').description('Manage topic communities');
+
+  /**
+   * mx communities list [options]
+   * List communities with pagination
+   */
+  communities
+    .command('list')
+    .description('List communities')
+    .option('--page <number>', 'Page number', '0')
+    .option('--limit <number>', 'Results per page', '20')
+    .option('--context-id <id>', 'Filter by context')
+    .option('--min-size <number>', 'Minimum community size')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (options) => {
+      try {
+        const page = parseInt(options.page, 10);
+        const limit = parseInt(options.limit, 10);
+        const offset = page * limit;
+
+        const result = await listCommunities({
+          ...getApiOptions(),
+          query: {
+            limit,
+            offset,
+          },
+        });
+
+        const responseData = result.data as any;
+
+        if (options.format === 'table' || !options.format) {
+          const tableData = (responseData?.data || []).map((c: any) => ({
+            id: c.id,
+            name: c.name || 'N/A',
+            memberCount: c.memberCount || 0,
+            topicCount: c.topicCount || 0,
+            createdAt: new Date(c.createdAt).toLocaleDateString(),
+          }));
+
+          printOutput(tableData, options.format as OutputFormat, {
+            columns: ['id', 'name', 'memberCount', 'topicCount', 'createdAt'],
+            maxColumnWidth: 20,
+          });
+
+          const pagination = responseData?.pagination;
+          if (pagination) {
+            console.log(
+              chalk.gray(
+                `\nShowing ${pagination.offset + 1}-${
+                  pagination.offset + (responseData?.data?.length || 0)
+                } (Page ${page + 1})`
+              )
+            );
+          }
+        } else {
+          printOutput(responseData, options.format as OutputFormat);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx communities get <id>
+   * Get a specific community by ID
+   */
+  communities
+    .command('get <id>')
+    .description('Get community details')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (id: string, options) => {
+      try {
+        const result = await getCommunityById({
+          ...getApiOptions(),
+          path: { id },
+        });
+
+        printOutput(result.data, options.format as OutputFormat);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx communities merge [options]
+   * Merge two communities
+   */
+  communities
+    .command('merge')
+    .description('Merge two communities')
+    .option('--source-id <id>', 'Source community ID')
+    .option('--target-id <id>', 'Target community ID')
+    .option('--force', 'Skip confirmation')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (options) => {
+      try {
+        if (!options.sourceId || !options.targetId) {
+          console.log(chalk.red('Error: --source-id and --target-id are required'));
+          return;
+        }
+
+        if (!options.force) {
+          const answer = await inquirer.prompt([
+            {
+              type: 'confirm',
+              name: 'confirm',
+              message: `Merge community ${options.sourceId} into ${options.targetId}?`,
+              default: false,
+            },
+          ]);
+
+          if (!answer.confirm) {
+            console.log(chalk.gray('Merge cancelled'));
+            return;
+          }
+        }
+
+        const spinner = ora('Merging communities...').start();
+
+        const result = await mergeCommunities({
+          ...getApiOptions(),
+          body: {
+            sourceCommunityId: options.sourceId,
+            targetCommunityId: options.targetId,
+          },
+        });
+
+        spinner.succeed('Communities merged successfully');
+        printOutput(result.data, options.format as OutputFormat);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+}

package/src/commands/config.ts

@@ -0,0 +1,144 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { config } from '../lib/config';
+import { handleError, CLIError } from '../lib/errors';
+import { CLIConfig } from '../types';
+
+/**
+ * Register configuration commands
+ * @param program - Commander program instance
+ */
+export function registerConfigCommands(program: Command): void {
+  const configCmd = program.command('config').description('Manage CLI configuration');
+
+  /**
+   * mx config get <key>
+   * Get a specific configuration value
+   */
+  configCmd
+    .command('get <key>')
+    .description('Get a configuration value')
+    .action(async (key: string) => {
+      try {
+        const validKeys: (keyof CLIConfig)[] = ['apiUrl', 'defaultFormat', 'defaultPageSize'];
+
+        if (!validKeys.includes(key as keyof CLIConfig)) {
+          throw new CLIError(`Invalid config key: ${key}. Valid keys are: ${validKeys.join(', ')}`);
+        }
+
+        const value = config.get(key as keyof CLIConfig);
+
+        if (value === undefined) {
+          console.log(chalk.gray('(not set)'));
+        } else {
+          console.log(value);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx config set <key> <value>
+   * Set a configuration value
+   */
+  configCmd
+    .command('set <key> <value>')
+    .description('Set a configuration value')
+    .action(async (key: string, value: string) => {
+      try {
+        // Validate key
+        const validKeys: (keyof CLIConfig)[] = ['apiUrl', 'defaultFormat', 'defaultPageSize'];
+
+        if (!validKeys.includes(key as keyof CLIConfig)) {
+          throw new CLIError(`Invalid config key: ${key}. Valid keys are: ${validKeys.join(', ')}`);
+        }
+
+        // Validate value based on key
+        if (key === 'apiUrl') {
+          try {
+            new URL(value);
+          } catch {
+            throw new CLIError('Invalid URL format');
+          }
+        } else if (key === 'defaultFormat') {
+          if (!['json', 'table', 'yaml'].includes(value)) {
+            throw new CLIError('Invalid format. Must be one of: json, table, yaml');
+          }
+        } else if (key === 'defaultPageSize') {
+          const num = parseInt(value, 10);
+          if (isNaN(num) || num < 1 || num > 100) {
+            throw new CLIError('Invalid page size. Must be a number between 1 and 100');
+          }
+          config.set(key, num);
+          console.log(chalk.green(`✓ ${key} set to ${num}`));
+          return;
+        }
+
+        config.set(key as keyof CLIConfig, value);
+        console.log(chalk.green(`✓ ${key} set to ${value}`));
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx config list
+   * List all configuration values
+   */
+  configCmd
+    .command('list')
+    .description('List all configuration values')
+    .action(async () => {
+      try {
+        const allConfig = config.get() as CLIConfig;
+
+        const table = new Table({
+          head: [chalk.cyan('Key'), chalk.cyan('Value'), chalk.cyan('Source')],
+          colWidths: [25, 40, 20],
+          wordWrap: true,
+        });
+
+        // Check for environment variable overrides
+        const envOverrides = {
+          apiUrl: process.env.MX_API_URL,
+          defaultFormat: process.env.MX_OUTPUT_FORMAT,
+        };
+
+        table.push(
+          [
+            'apiUrl',
+            envOverrides.apiUrl || allConfig.apiUrl,
+            envOverrides.apiUrl ? chalk.yellow('env') : 'config',
+          ],
+          [
+            'defaultFormat',
+            envOverrides.defaultFormat || allConfig.defaultFormat,
+            envOverrides.defaultFormat ? chalk.yellow('env') : 'config',
+          ],
+          ['defaultPageSize', String(allConfig.defaultPageSize), 'config']
+        );
+
+        console.log(table.toString());
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx config reset
+   * Reset configuration to defaults
+   */
+  configCmd
+    .command('reset')
+    .description('Reset configuration to defaults')
+    .action(async () => {
+      try {
+        config.reset();
+        console.log(chalk.green('✓ Configuration reset to defaults'));
+      } catch (error) {
+        handleError(error);
+      }
+    });
+}

package/src/commands/conversations.ts

@@ -0,0 +1,176 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import {
+  listConversations,
+  searchConversations,
+  getConversationSummary,
+  getConversationTimeline,
+  findConversationsByTopic,
+} from '@memnexus-ai/mx-typescript-sdk';
+import { getApiOptions } from '../lib/api-client';
+import { handleError } from '../lib/errors';
+import { printOutput } from '../lib/formatters';
+import { OutputFormat } from '../types';
+
+/**
+ * Register conversation query commands
+ * @param program - Commander program instance
+ */
+export function registerConversationsCommands(program: Command): void {
+  const conversations = program
+    .command('conversations')
+    .description('Query and manage conversations');
+
+  /**
+   * mx conversations list [options]
+   * List conversations with pagination
+   */
+  conversations
+    .command('list')
+    .description('List conversations')
+    .option('--page <number>', 'Page number', '0')
+    .option('--limit <number>', 'Results per page', '20')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (options) => {
+      try {
+        const page = parseInt(options.page, 10);
+        const limit = parseInt(options.limit, 10);
+        const offset = page * limit;
+
+        const result = await listConversations({
+          ...getApiOptions(),
+          query: { limit, offset },
+        });
+
+        const responseData = result.data as any;
+
+        // Format for table display
+        if (options.format === 'table' || !options.format) {
+          const tableData = (responseData?.data || []).map((c: any) => ({
+            id: c.id,
+            title: c.title || c.id,
+            messageCount: c.messageCount || 0,
+            createdAt: new Date(c.createdAt).toLocaleDateString(),
+          }));
+
+          printOutput(tableData, options.format as OutputFormat, {
+            columns: ['id', 'title', 'messageCount', 'createdAt'],
+            maxColumnWidth: 30,
+          });
+
+          const pagination = responseData?.pagination;
+          if (pagination) {
+            console.log(
+              chalk.gray(
+                `\nShowing ${pagination.offset + 1}-${
+                  pagination.offset + (responseData?.data?.length || 0)
+                } (Page ${page + 1})`
+              )
+            );
+          }
+        } else {
+          printOutput(responseData, options.format as OutputFormat);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx conversations summary <id>
+   * Get conversation summary
+   */
+  conversations
+    .command('summary <id>')
+    .description('Get conversation summary')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (id: string, options) => {
+      try {
+        const result = await getConversationSummary({
+          ...getApiOptions(),
+          path: { conversationId: id },
+        });
+        printOutput(result.data, options.format as OutputFormat);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx conversations timeline <id>
+   * Get conversation timeline (chronological messages)
+   */
+  conversations
+    .command('timeline <id>')
+    .description('Get conversation timeline')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (id: string, options) => {
+      try {
+        const result = await getConversationTimeline({
+          ...getApiOptions(),
+          path: { conversationId: id },
+        });
+        printOutput(result.data, options.format as OutputFormat);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx conversations search [options]
+   * Search conversations
+   */
+  conversations
+    .command('search')
+    .description('Search conversations')
+    .option('--query <text>', 'Search query')
+    .option('--limit <number>', 'Maximum results', '20')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (options) => {
+      try {
+        if (!options.query) {
+          console.log(chalk.red('Error: --query is required'));
+          return;
+        }
+
+        const result = await searchConversations({
+          ...getApiOptions(),
+          body: {
+            query: options.query,
+            limit: parseInt(options.limit, 10),
+          },
+        });
+
+        printOutput(result.data, options.format as OutputFormat);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx conversations by-topic [options]
+   * Find conversations by topic
+   */
+  conversations
+    .command('by-topic')
+    .description('Find conversations by topic')
+    .option('--topic-id <id>', 'Topic ID')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (options) => {
+      try {
+        if (!options.topicId) {
+          console.log(chalk.red('Error: --topic-id is required'));
+          return;
+        }
+
+        const result = await findConversationsByTopic({
+          ...getApiOptions(),
+          body: { topicId: options.topicId },
+        });
+
+        printOutput(result.data, options.format as OutputFormat);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+}