@memnexus-ai/cli 0.1.0

package/src/commands/memories.ts

@@ -0,0 +1,332 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import {
+  listMemories,
+  getMemoryById,
+  createMemory,
+  updateMemory,
+  deleteMemory,
+  searchMemories,
+} from '@memnexus-ai/mx-typescript-sdk';
+import { getApiOptions } from '../lib/api-client';
+import { handleError } from '../lib/errors';
+import { printOutput } from '../lib/formatters';
+import { createSpinner } from '../lib/spinner';
+import { OutputFormat } from '../types';
+
+/**
+ * Register memory management commands
+ * @param program - Commander program instance
+ */
+export function registerMemoriesCommands(program: Command): void {
+  const memories = program.command('memories').description('Manage memories');
+
+  /**
+   * mx memories list [options]
+   * List memories with pagination
+   */
+  memories
+    .command('list')
+    .description('List memories')
+    .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 spinner = createSpinner('Fetching memories...', options.format).start();
+
+        const result = await listMemories({
+          ...getApiOptions(),
+          query: { limit, offset },
+        });
+
+        spinner.succeed(`Found ${result.data?.data?.length || 0} memories`);
+
+        // Format for table display
+        if (options.format === 'table' || !options.format) {
+          const tableData =
+            result.data?.data?.map((m: any) => ({
+              id: m.id,
+              content: m.content?.substring(0, 50) + (m.content?.length > 50 ? '...' : ''),
+              memoryType: m.memoryType || 'N/A',
+              createdAt: new Date(m.createdAt).toLocaleDateString(),
+            })) || [];
+
+          printOutput(tableData, options.format as OutputFormat, {
+            columns: ['id', 'content', 'memoryType', 'createdAt'],
+            maxColumnWidth: 30,
+          });
+
+          const pagination = result.data?.pagination;
+          if (pagination) {
+            console.log(
+              chalk.gray(
+                `\nShowing ${pagination.offset + 1}-${
+                  pagination.offset + (result.data?.data?.length || 0)
+                } (Page ${page + 1})`
+              )
+            );
+          }
+        } else {
+          printOutput(result.data, options.format as OutputFormat);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx memories get <id>
+   * Get a specific memory by ID
+   */
+  memories
+    .command('get <id>')
+    .description('Get a specific memory')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (id: string, options) => {
+      try {
+        const result = await getMemoryById({
+          ...getApiOptions(),
+          path: { id },
+        });
+        printOutput(result.data, options.format as OutputFormat);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx memories create [options]
+   * Create a new memory
+   */
+  memories
+    .command('create')
+    .description('Create a new memory')
+    .option('--content <text>', 'Memory content')
+    .option('--memory-type <type>', 'Memory type (episodic|semantic|procedural)')
+    .option('--context <context>', 'Context identifier')
+    .option('--topics <topics>', 'Comma-separated topics')
+    .option('--importance <number>', 'Importance score (0-1)')
+    .option('--interactive', 'Interactive mode')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (options) => {
+      try {
+        let memoryData: any = {};
+
+        if (options.interactive || !options.content) {
+          // Interactive mode
+          const answers = await inquirer.prompt([
+            {
+              type: 'input',
+              name: 'content',
+              message: 'Memory content:',
+              default: options.content,
+              validate: (input: string) => input.trim().length > 0 || 'Content is required',
+            },
+            {
+              type: 'list',
+              name: 'memoryType',
+              message: 'Memory type:',
+              choices: ['episodic', 'semantic', 'procedural'],
+              default: options.memoryType || 'episodic',
+            },
+            {
+              type: 'input',
+              name: 'context',
+              message: 'Context (optional):',
+              default: options.context,
+            },
+            {
+              type: 'input',
+              name: 'topics',
+              message: 'Topics (comma-separated, optional):',
+              default: options.topics,
+            },
+            {
+              type: 'number',
+              name: 'importance',
+              message: 'Importance (0-1, optional):',
+              default: options.importance ? parseFloat(options.importance) : undefined,
+            },
+          ]);
+
+          memoryData = {
+            content: answers.content,
+            memoryType: answers.memoryType,
+            context: answers.context || undefined,
+            topics: answers.topics
+              ? answers.topics.split(',').map((t: string) => t.trim())
+              : undefined,
+            importance: answers.importance || undefined,
+          };
+        } else {
+          // Direct mode
+          memoryData = {
+            content: options.content,
+            memoryType: options.memoryType || 'episodic',
+            context: options.context,
+            topics: options.topics
+              ? options.topics.split(',').map((t: string) => t.trim())
+              : undefined,
+            importance: options.importance ? parseFloat(options.importance) : undefined,
+          };
+        }
+
+        const spinner = createSpinner('Creating memory...', options.format).start();
+
+        const result = await createMemory({
+          ...getApiOptions(),
+          body: memoryData,
+        });
+
+        const memory = result.data?.data;
+        spinner.succeed(`Memory created with ID: ${memory?.id}`);
+        printOutput(memory, options.format as OutputFormat);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx memories update <id> [options]
+   * Update an existing memory
+   */
+  memories
+    .command('update <id>')
+    .description('Update an existing memory')
+    .option('--content <text>', 'Updated content')
+    .option('--memory-type <type>', 'Updated memory type')
+    .option('--context <context>', 'Updated context')
+    .option('--topics <topics>', 'Updated topics (comma-separated)')
+    .option('--importance <number>', 'Updated importance (0-1)')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (id: string, options) => {
+      try {
+        const updates: any = {};
+
+        if (options.content) updates.content = options.content;
+        if (options.memoryType) updates.memoryType = options.memoryType;
+        if (options.context) updates.context = options.context;
+        if (options.topics) updates.topics = options.topics.split(',').map((t: string) => t.trim());
+        if (options.importance) updates.importance = parseFloat(options.importance);
+
+        if (Object.keys(updates).length === 0) {
+          console.log(chalk.yellow('No updates provided. Use --help to see available options.'));
+          return;
+        }
+
+        const spinner = createSpinner('Updating memory...', options.format).start();
+
+        const result = await updateMemory({
+          ...getApiOptions(),
+          path: { id },
+          body: updates,
+        });
+
+        const memory = result.data?.data;
+        spinner.succeed(`Memory ${id} updated successfully`);
+        printOutput(memory, options.format as OutputFormat);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx memories delete <id>
+   * Delete a memory
+   */
+  memories
+    .command('delete <id>')
+    .description('Delete a memory')
+    .option('--force', 'Skip confirmation prompt')
+    .action(async (id: string, options) => {
+      try {
+        if (!options.force) {
+          const answers = await inquirer.prompt([
+            {
+              type: 'confirm',
+              name: 'confirm',
+              message: `Are you sure you want to delete memory ${id}?`,
+              default: false,
+            },
+          ]);
+
+          if (!answers.confirm) {
+            console.log(chalk.yellow('Delete cancelled'));
+            return;
+          }
+        }
+
+        const spinner = createSpinner('Deleting memory...', 'table').start();
+
+        await deleteMemory({
+          ...getApiOptions(),
+          path: { id },
+        });
+
+        spinner.succeed(`Memory ${id} deleted successfully`);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx memories search [options]
+   * Search memories
+   */
+  memories
+    .command('search')
+    .description('Search memories')
+    .option('--query <text>', 'Search query')
+    .option('--limit <number>', 'Maximum results', '20')
+    .option('--mode <mode>', 'Search mode (unified|content|facts)', 'unified')
+    .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 spinner = createSpinner('Searching memories...', options.format).start();
+
+        const result = await searchMemories({
+          ...getApiOptions(),
+          body: {
+            query: options.query,
+            limit: parseInt(options.limit, 10),
+            mode: options.mode as 'unified' | 'content' | 'facts',
+          },
+        });
+
+        const searchData = result.data;
+        spinner.succeed(`Found ${searchData?.data?.length || 0} results`);
+
+        // Format for table display
+        if (options.format === 'table' || !options.format) {
+          const tableData = (searchData?.data || []).map((memory: any) => ({
+            id: memory.id || 'N/A',
+            content: memory.content?.substring(0, 50) + (memory.content?.length > 50 ? '...' : ''),
+            memoryType: memory.memoryType || 'N/A',
+            createdAt: new Date(memory.createdAt).toLocaleDateString(),
+          }));
+
+          printOutput(tableData, options.format as OutputFormat, {
+            columns: ['id', 'content', 'memoryType', 'createdAt'],
+            maxColumnWidth: 30,
+          });
+
+          console.log(chalk.gray(`\nFound ${searchData?.count || 0} results`));
+        } else {
+          printOutput(searchData, options.format as OutputFormat);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+}

package/src/commands/patterns.ts

@@ -0,0 +1,251 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import {
+  listPatterns,
+  compilePatterns,
+  updatePattern,
+  recordPatternFeedback,
+  getBehavioralState,
+  updateBehavioralState,
+} 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 pattern management commands
+ * @param program - Commander program instance
+ */
+export function registerPatternsCommands(program: Command): void {
+  const patterns = program.command('patterns').description('Manage behavioral patterns');
+
+  /**
+   * mx patterns list [options]
+   * List patterns with pagination
+   */
+  patterns
+    .command('list')
+    .description('List patterns')
+    .option('--page <number>', 'Page number', '0')
+    .option('--limit <number>', 'Results per page', '20')
+    .option('--context-id <id>', 'Filter by context')
+    .option('--type <type>', 'Pattern type (behavioral|temporal|semantic)')
+    .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 listPatterns({
+          ...getApiOptions(),
+          query: {
+            limit,
+            offset,
+          },
+        });
+
+        const responseData = result.data as any;
+        if (options.format === 'table' || !options.format) {
+          const tableData = (responseData?.data || []).map((p: any) => ({
+            id: p.id,
+            type: p.type || 'N/A',
+            description:
+              p.description?.substring(0, 40) + (p.description?.length > 40 ? '...' : ''),
+            confidence: p.confidence || 0,
+            lastUpdated: new Date(p.lastUpdated).toLocaleDateString(),
+          }));
+
+          printOutput(tableData, options.format as OutputFormat, {
+            columns: ['id', 'type', 'description', 'confidence', 'lastUpdated'],
+            maxColumnWidth: 20,
+          });
+
+          const pagination = responseData?.pagination;
+          if (pagination) {
+            console.log(
+              chalk.gray(
+                `\nShowing ${pagination.offset + 1}-${
+                  pagination.offset + pagination.count
+                } (Page ${page + 1})`
+              )
+            );
+          }
+        } else {
+          printOutput(responseData, options.format as OutputFormat);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx patterns compile [options]
+   * Compile patterns from memories
+   */
+  patterns
+    .command('compile')
+    .description('Compile patterns from memories')
+    .option('--context-id <id>', 'Context ID (required)')
+    .option('--force', 'Force recompilation')
+    .option('--pattern-types <types>', 'Comma-separated pattern types to compile')
+    .action(async (options) => {
+      try {
+        if (!options.contextId) {
+          console.log(chalk.red('Error: --context-id is required'));
+          return;
+        }
+
+        const spinner = ora('Compiling patterns...').start();
+
+        const result = await compilePatterns({
+          ...getApiOptions(),
+          body: {
+            minOccurrences: 2,
+            timeWindow: '30d',
+          },
+        });
+
+        spinner.succeed('Patterns compiled successfully');
+        printOutput(result.data, 'json');
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx patterns update <id> [options]
+   * Update a pattern
+   */
+  patterns
+    .command('update <id>')
+    .description('Update a pattern')
+    .option('--description <text>', 'Updated description')
+    .option('--confidence <number>', 'Updated confidence (0-1)')
+    .option('--active <boolean>', 'Enable/disable pattern')
+    .option('--metadata <json>', 'Updated metadata')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (id: string, options) => {
+      try {
+        if (!options.description && !options.confidence && !options.active && !options.metadata) {
+          console.log(chalk.red('Error: At least one option is required'));
+          return;
+        }
+
+        const updates: any = {};
+
+        if (options.description) updates.description = options.description;
+        if (options.confidence) updates.confidence = parseFloat(options.confidence);
+        if (options.active) updates.active = options.active === 'true';
+        if (options.metadata) updates.metadata = JSON.parse(options.metadata);
+
+        const result = await updatePattern({
+          ...getApiOptions(),
+          path: { id },
+          body: updates,
+        });
+
+        console.log(chalk.green('✓ Pattern updated successfully'));
+        printOutput(result.data, options.format as OutputFormat);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx patterns feedback [options]
+   * Record pattern feedback
+   */
+  patterns
+    .command('feedback')
+    .description('Record pattern feedback')
+    .option('--pattern-id <id>', 'Pattern ID (required)')
+    .option('--feedback-type <type>', 'Feedback type (positive|negative|neutral) (required)')
+    .option('--comment <text>', 'Feedback comment')
+    .option('--context-id <id>', 'Context ID')
+    .action(async (options) => {
+      try {
+        if (!options.patternId || !options.feedbackType) {
+          console.log(chalk.red('Error: --pattern-id and --feedback-type are required'));
+          return;
+        }
+
+        const spinner = ora('Recording feedback...').start();
+
+        await recordPatternFeedback({
+          ...getApiOptions(),
+          body: {
+            patternId: options.patternId,
+            feedback: options.feedbackType,
+          },
+        });
+
+        spinner.succeed('Feedback recorded successfully');
+        console.log(chalk.green('✓ Feedback recorded'));
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx patterns behavior-state [options]
+   * Get behavioral state
+   */
+  patterns
+    .command('behavior-state')
+    .description('Get behavioral state')
+    .option('--context-id <id>', 'Context ID (required)')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (options) => {
+      try {
+        if (!options.contextId) {
+          console.log(chalk.red('Error: --context-id is required'));
+          return;
+        }
+
+        const result = await getBehavioralState({
+          ...getApiOptions(),
+        });
+
+        printOutput(result.data, options.format as OutputFormat);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx patterns set-behavior-state [options]
+   * Set behavioral state
+   */
+  patterns
+    .command('set-behavior-state')
+    .description('Set behavioral state')
+    .option('--context-id <id>', 'Context ID (required)')
+    .option('--state <json>', 'Behavioral state JSON (required)')
+    .option('--merge', 'Merge with existing state instead of replacing')
+    .action(async (options) => {
+      try {
+        if (!options.contextId || !options.state) {
+          console.log(chalk.red('Error: --context-id and --state are required'));
+          return;
+        }
+
+        const spinner = ora('Setting behavioral state...').start();
+
+        const state = JSON.parse(options.state);
+        await updateBehavioralState({
+          ...getApiOptions(),
+          body: {
+            state,
+          },
+        });
+
+        spinner.succeed('Behavioral state set successfully');
+        console.log(chalk.green('✓ State updated'));
+      } catch (error) {
+        handleError(error);
+      }
+    });
+}

package/src/commands/system.ts

@@ -0,0 +1,102 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { getSystemHealth, getContextStatus, getFeatureFlags } 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 system management commands
+ * @param program - Commander program instance
+ */
+export function registerSystemCommands(program: Command): void {
+  const system = program.command('system').description('System health and statistics');
+
+  /**
+   * mx system health
+   * Check system health status
+   */
+  system
+    .command('health')
+    .description('Check system health')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (options) => {
+      try {
+        const spinner = ora('Checking system health...').start();
+
+        const result = await getSystemHealth({
+          ...getApiOptions(),
+        });
+
+        spinner.succeed('Health check completed');
+
+        const healthData = result.data as any;
+        if (healthData) {
+          const status = healthData.status === 'healthy' ? chalk.green('✓') : chalk.red('✗');
+          console.log(`${status} Status: ${healthData.status}`);
+
+          if (healthData.components) {
+            console.log(chalk.gray('\nComponent Status:'));
+            Object.entries(healthData.components).forEach(([name, status]: [string, any]) => {
+              const icon = status.status === 'healthy' ? chalk.green('✓') : chalk.red('✗');
+              console.log(`  ${icon} ${name}: ${status.status}`);
+            });
+          }
+
+          if (options.format && options.format !== 'table') {
+            printOutput(healthData, options.format as OutputFormat);
+          }
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx system status
+   * Get detailed system status
+   */
+  system
+    .command('status')
+    .description('Get system status')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (options) => {
+      try {
+        const spinner = ora('Fetching system status...').start();
+
+        const result = await getContextStatus({
+          ...getApiOptions(),
+        });
+
+        spinner.succeed('Status retrieved');
+        printOutput(result.data, options.format as OutputFormat);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  /**
+   * mx system features
+   * Get feature flags
+   */
+  system
+    .command('features')
+    .description('Get feature flags')
+    .option('--format <format>', 'Output format (json|table|yaml)')
+    .action(async (options) => {
+      try {
+        const spinner = ora('Fetching feature flags...').start();
+
+        const result = await getFeatureFlags({
+          ...getApiOptions(),
+        });
+
+        spinner.succeed('Feature flags retrieved');
+        printOutput(result.data, options.format as OutputFormat);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+}