@memnexus-ai/cli 0.1.0 → 0.1.2

package/src/commands/memories.ts

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

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

@@ -1,102 +0,0 @@
-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);
-      }
-    });
-}